Full Code of py-pdf/pypdf for AI

gitextract_mui37wu0/

├── .git-blame-ignore-revs
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug-report.md
│   │   └── feature-request.md
│   ├── SECURITY.md
│   ├── dependabot.yaml
│   ├── scripts/
│   │   ├── check_gh_pages_updates.py
│   │   ├── check_pr_title.py
│   │   └── check_urls.py
│   └── workflows/
│       ├── benchmark.yaml
│       ├── create-github-release.yaml
│       ├── gh-pages-check.yaml
│       ├── github-ci.yaml
│       ├── publish-to-pypi.yaml
│       ├── release.yaml
│       ├── title-check.yaml
│       └── urls-check.yaml
├── .gitignore
├── .gitmodules
├── .pre-commit-config.yaml
├── .readthedocs.yaml
├── CHANGELOG.md
├── CONTRIBUTING.md
├── CONTRIBUTORS.md
├── LICENSE
├── Makefile
├── README.md
├── docs/
│   ├── Makefile
│   ├── _static/
│   │   └── releasing.drawio
│   ├── conf.py
│   ├── dev/
│   │   ├── cmaps.md
│   │   ├── deprecations.md
│   │   ├── documentation.md
│   │   ├── intro.md
│   │   ├── pdf-format.md
│   │   ├── pypdf-parsing.md
│   │   ├── pypdf-writing.md
│   │   ├── releasing.md
│   │   └── testing.md
│   ├── index.rst
│   ├── make.bat
│   ├── meta/
│   │   ├── changelog-v1.md
│   │   ├── comparisons.md
│   │   ├── faq.md
│   │   ├── history.md
│   │   ├── migration-1-to-2.md
│   │   ├── project-governance.md
│   │   ├── scope-of-pypdf.md
│   │   └── taking-ownership.md
│   ├── modules/
│   │   ├── Destination.rst
│   │   ├── DocumentInformation.rst
│   │   ├── Field.rst
│   │   ├── Fit.rst
│   │   ├── PageObject.rst
│   │   ├── PageRange.rst
│   │   ├── PaperSize.rst
│   │   ├── PdfDocCommon.rst
│   │   ├── PdfReader.rst
│   │   ├── PdfWriter.rst
│   │   ├── RectangleObject.rst
│   │   ├── Transformation.rst
│   │   ├── XmpInformation.rst
│   │   ├── annotations.rst
│   │   ├── constants.rst
│   │   ├── errors.rst
│   │   └── generic.rst
│   └── user/
│       ├── add-javascript.md
│       ├── add-watermark.md
│       ├── adding-pdf-annotations.md
│       ├── cropping-and-transforming.md
│       ├── encryption-decryption.md
│       ├── extract-images.md
│       ├── extract-text.md
│       ├── file-size.md
│       ├── forms.md
│       ├── handle-attachments.md
│       ├── handling-outlines.md
│       ├── installation.md
│       ├── merging-pdfs.md
│       ├── metadata.md
│       ├── pdf-version-support.md
│       ├── pdfa-compliance.md
│       ├── post-processing-in-text-extraction.md
│       ├── reading-pdf-annotations.md
│       ├── robustness.md
│       ├── security.md
│       ├── streaming-data.md
│       ├── suppress-warnings.md
│       └── viewer-preferences.md
├── make_release.py
├── pypdf/
│   ├── __init__.py
│   ├── _cmap.py
│   ├── _codecs/
│   │   ├── __init__.py
│   │   ├── _codecs.py
│   │   ├── adobe_glyphs.py
│   │   ├── core_font_metrics.py
│   │   ├── pdfdoc.py
│   │   ├── std.py
│   │   ├── symbol.py
│   │   └── zapfding.py
│   ├── _crypt_providers/
│   │   ├── __init__.py
│   │   ├── _base.py
│   │   ├── _cryptography.py
│   │   ├── _fallback.py
│   │   └── _pycryptodome.py
│   ├── _doc_common.py
│   ├── _encryption.py
│   ├── _font.py
│   ├── _page.py
│   ├── _page_labels.py
│   ├── _protocols.py
│   ├── _reader.py
│   ├── _text_extraction/
│   │   ├── __init__.py
│   │   ├── _layout_mode/
│   │   │   ├── __init__.py
│   │   │   ├── _fixed_width_page.py
│   │   │   ├── _text_state_manager.py
│   │   │   └── _text_state_params.py
│   │   └── _text_extractor.py
│   ├── _utils.py
│   ├── _version.py
│   ├── _writer.py
│   ├── annotations/
│   │   ├── __init__.py
│   │   ├── _base.py
│   │   ├── _markup_annotations.py
│   │   └── _non_markup_annotations.py
│   ├── constants.py
│   ├── errors.py
│   ├── filters.py
│   ├── generic/
│   │   ├── __init__.py
│   │   ├── _appearance_stream.py
│   │   ├── _base.py
│   │   ├── _data_structures.py
│   │   ├── _files.py
│   │   ├── _fit.py
│   │   ├── _image_inline.py
│   │   ├── _image_xobject.py
│   │   ├── _link.py
│   │   ├── _outline.py
│   │   ├── _rectangle.py
│   │   ├── _utils.py
│   │   └── _viewerpref.py
│   ├── pagerange.py
│   ├── papersizes.py
│   ├── py.typed
│   ├── types.py
│   └── xmp.py
├── pyproject.toml
├── requirements/
│   ├── ci-3.11.txt
│   ├── ci.in
│   ├── ci.txt
│   ├── dev.in
│   ├── dev.txt
│   ├── docs.in
│   └── docs.txt
├── resources/
│   ├── 010-pdflatex-forms.txt
│   ├── AEO.1172.layout.rot180.txt
│   ├── AEO.1172.layout.txt
│   ├── Claim Maker Alerts Guide_pg2.layout.txt
│   ├── Epic.Page.layout.txt
│   ├── afm_to_dataclass.py
│   ├── crazyones.txt
│   ├── crazyones_layout_vertical_space.txt
│   ├── crazyones_layout_vertical_space_font_height_weight.txt
│   ├── jpeg.txt
│   ├── multicolumn-lorem-ipsum.txt
│   └── toy.layout.txt
└── tests/
    ├── __init__.py
    ├── bench.py
    ├── conftest.py
    ├── example_files.yaml
    ├── generic/
    │   ├── __init__.py
    │   ├── test_base.py
    │   ├── test_data_structures.py
    │   ├── test_files.py
    │   ├── test_image_inline.py
    │   ├── test_image_xobject.py
    │   └── test_link.py
    ├── scripts/
    │   ├── __init__.py
    │   ├── data/
    │   │   └── commits__version_4_0_1.json
    │   ├── test_example_files.py
    │   └── test_make_release.py
    ├── test_annotations.py
    ├── test_appearance_stream.py
    ├── test_cmap.py
    ├── test_codecs.py
    ├── test_constants.py
    ├── test_doc_common.py
    ├── test_encryption.py
    ├── test_filters.py
    ├── test_font.py
    ├── test_forms.py
    ├── test_generic.py
    ├── test_images.py
    ├── test_javascript.py
    ├── test_merger.py
    ├── test_page.py
    ├── test_page_labels.py
    ├── test_pagerange.py
    ├── test_papersizes.py
    ├── test_pdfa.py
    ├── test_protocols.py
    ├── test_reader.py
    ├── test_text_extraction.py
    ├── test_utils.py
    ├── test_workflows.py
    ├── test_writer.py
    ├── test_xmp.py
    └── utils.py

SYMBOL INDEX (1963 symbols across 85 files)

FILE: .github/scripts/check_gh_pages_updates.py
  function fetch_json (line 18) | def fetch_json(url: str) -> dict:
  function fetch_bytes (line 24) | def fetch_bytes(url: str) -> bytes:
  function get_latest_version (line 30) | def get_latest_version(pkg: str) -> str:
  function sri_hash (line 36) | def sri_hash(content: bytes) -> str:
  function scan_html (line 42) | def scan_html(path: Path) -> list[re.Match[str]]:
  function main (line 48) | def main() -> None:

FILE: .github/scripts/check_urls.py
  function get_urls_from_test_files (line 24) | def get_urls_from_test_files() -> Iterator[str]:
  function get_urls_from_example_files (line 39) | def get_urls_from_example_files() -> Iterator[str]:
  function check_url (line 45) | def check_url(url: str) -> bool:
  function main (line 72) | def main() -> bool:

FILE: make_release.py
  class Change (line 16) | class Change:
  function main (line 26) | def main(changelog_path: str) -> None:
  function print_instructions (line 64) | def print_instructions(new_version: str) -> None:
  function adjust_version_py (line 75) | def adjust_version_py(version: str) -> None:
  function get_version_interactive (line 81) | def get_version_interactive(new_version: str, changes: str) -> str:
  function is_semantic_version (line 97) | def is_semantic_version(version: str) -> bool:
  function write_commit_msg_file (line 108) | def write_commit_msg_file(new_version: str, commit_changes: str) -> None:
  function write_release_msg_file (line 122) | def write_release_msg_file(
  function strip_header (line 138) | def strip_header(md: str) -> str:
  function version_bump (line 143) | def version_bump(git_tag: str) -> str:
  function get_changelog (line 159) | def get_changelog(changelog_path: str) -> str:
  function write_changelog (line 174) | def write_changelog(new_changelog: str, changelog_path: str) -> None:
  function get_formatted_changes (line 187) | def get_formatted_changes(git_tag: str) -> tuple[str, str]:
  function get_most_recent_git_tag (line 266) | def get_most_recent_git_tag() -> str:
  function get_author_mapping (line 279) | def get_author_mapping(line_count: int) -> dict[str, str]:
  function get_git_commits_since_tag (line 305) | def get_git_commits_since_tag(git_tag: str) -> list[Change]:
  function parse_commit_line (line 336) | def parse_commit_line(line: str, authors: dict[str, str]) -> Change:

FILE: pypdf/_cmap.py
  function get_encoding (line 41) | def get_encoding(
  function _parse_encoding (line 59) | def _parse_encoding(
  function _parse_to_unicode (line 118) | def _parse_to_unicode(
  function prepare_cm (line 151) | def prepare_cm(ft: DictionaryObject) -> bytes:
  function process_cm_line (line 192) | def process_cm_line(
  function _check_mapping_size (line 225) | def _check_mapping_size(size: int) -> None:
  function parse_bfrange (line 230) | def parse_bfrange(
  function parse_bfchar (line 298) | def parse_bfchar(line: bytes, map_dict: dict[Any, Any], int_entry: list[...
  function _type1_alternative (line 322) | def _type1_alternative(

FILE: pypdf/_codecs/__init__.py
  function fill_from_encoding (line 8) | def fill_from_encoding(enc: str) -> list[str]:
  function rev_encoding (line 18) | def rev_encoding(enc: list[str]) -> dict[str, int]:

FILE: pypdf/_codecs/_codecs.py
  class Codec (line 15) | class Codec(ABC):
    method encode (line 19) | def encode(self, data: bytes) -> bytes:
    method decode (line 32) | def decode(self, data: bytes) -> bytes:
  class LzwCodec (line 45) | class LzwCodec(Codec):
    method __init__ (line 53) | def __init__(self, max_output_length: int = 75_000_000) -> None:
    method _initialize_encoding_table (line 56) | def _initialize_encoding_table(self) -> None:
    method _increase_next_code (line 63) | def _increase_next_code(self) -> None:
    method encode (line 73) | def encode(self, data: bytes) -> bytes:
    method _pack_codes_into_bytes (line 115) | def _pack_codes_into_bytes(self, codes: list[int]) -> bytes:
    method _initialize_decoding_table (line 149) | def _initialize_decoding_table(self) -> None:
    method _next_code_decode (line 157) | def _next_code_decode(self, data: bytes) -> int:
    method decode (line 211) | def decode(self, data: bytes) -> bytes:
    method _add_entry_decode (line 267) | def _add_entry_decode(self, old_string: bytes, new_char: int) -> None:

FILE: pypdf/_codecs/adobe_glyphs.py
  function _complete (line 13963) | def _complete() -> None:

FILE: pypdf/_crypt_providers/_base.py
  class CryptBase (line 29) | class CryptBase:
    method encrypt (line 30) | def encrypt(self, data: bytes) -> bytes:  # pragma: no cover
    method decrypt (line 33) | def decrypt(self, data: bytes) -> bytes:  # pragma: no cover
  class CryptIdentity (line 37) | class CryptIdentity(CryptBase):

FILE: pypdf/_crypt_providers/_cryptography.py
  class CryptRC4 (line 47) | class CryptRC4(CryptBase):
    method __init__ (line 48) | def __init__(self, key: bytes) -> None:
    method encrypt (line 51) | def encrypt(self, data: bytes) -> bytes:
    method decrypt (line 55) | def decrypt(self, data: bytes) -> bytes:
  class CryptAES (line 60) | class CryptAES(CryptBase):
    method __init__ (line 61) | def __init__(self, key: bytes) -> None:
    method encrypt (line 64) | def encrypt(self, data: bytes) -> bytes:
    method decrypt (line 73) | def decrypt(self, data: bytes) -> bytes:
  function rc4_encrypt (line 91) | def rc4_encrypt(key: bytes, data: bytes) -> bytes:
  function rc4_decrypt (line 96) | def rc4_decrypt(key: bytes, data: bytes) -> bytes:
  function aes_ecb_encrypt (line 101) | def aes_ecb_encrypt(key: bytes, data: bytes) -> bytes:
  function aes_ecb_decrypt (line 106) | def aes_ecb_decrypt(key: bytes, data: bytes) -> bytes:
  function aes_cbc_encrypt (line 111) | def aes_cbc_encrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
  function aes_cbc_decrypt (line 116) | def aes_cbc_decrypt(key: bytes, iv: bytes, data: bytes) -> bytes:

FILE: pypdf/_crypt_providers/_fallback.py
  class CryptRC4 (line 37) | class CryptRC4(CryptBase):
    method __init__ (line 38) | def __init__(self, key: bytes) -> None:
    method encrypt (line 45) | def encrypt(self, data: bytes) -> bytes:
    method decrypt (line 57) | def decrypt(self, data: bytes) -> bytes:
  class CryptAES (line 61) | class CryptAES(CryptBase):
    method __init__ (line 62) | def __init__(self, key: bytes) -> None:
    method encrypt (line 65) | def encrypt(self, data: bytes) -> bytes:
    method decrypt (line 68) | def decrypt(self, data: bytes) -> bytes:
  function rc4_encrypt (line 72) | def rc4_encrypt(key: bytes, data: bytes) -> bytes:
  function rc4_decrypt (line 76) | def rc4_decrypt(key: bytes, data: bytes) -> bytes:
  function aes_ecb_encrypt (line 80) | def aes_ecb_encrypt(key: bytes, data: bytes) -> bytes:
  function aes_ecb_decrypt (line 84) | def aes_ecb_decrypt(key: bytes, data: bytes) -> bytes:
  function aes_cbc_encrypt (line 88) | def aes_cbc_encrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
  function aes_cbc_decrypt (line 92) | def aes_cbc_decrypt(key: bytes, iv: bytes, data: bytes) -> bytes:

FILE: pypdf/_crypt_providers/_pycryptodome.py
  class CryptRC4 (line 39) | class CryptRC4(CryptBase):
    method __init__ (line 40) | def __init__(self, key: bytes) -> None:
    method encrypt (line 43) | def encrypt(self, data: bytes) -> bytes:
    method decrypt (line 46) | def decrypt(self, data: bytes) -> bytes:
  class CryptAES (line 50) | class CryptAES(CryptBase):
    method __init__ (line 51) | def __init__(self, key: bytes) -> None:
    method encrypt (line 54) | def encrypt(self, data: bytes) -> bytes:
    method decrypt (line 60) | def decrypt(self, data: bytes) -> bytes:
  function rc4_encrypt (line 76) | def rc4_encrypt(key: bytes, data: bytes) -> bytes:
  function rc4_decrypt (line 80) | def rc4_decrypt(key: bytes, data: bytes) -> bytes:
  function aes_ecb_encrypt (line 84) | def aes_ecb_encrypt(key: bytes, data: bytes) -> bytes:
  function aes_ecb_decrypt (line 88) | def aes_ecb_decrypt(key: bytes, data: bytes) -> bytes:
  function aes_cbc_encrypt (line 92) | def aes_cbc_encrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
  function aes_cbc_decrypt (line 96) | def aes_cbc_decrypt(key: bytes, iv: bytes, data: bytes) -> bytes:

FILE: pypdf/_doc_common.py
  function convert_to_int (line 90) | def convert_to_int(d: bytes, size: int) -> Union[int, tuple[Any, ...]]:
  class DocumentInformation (line 98) | class DocumentInformation(DictionaryObject):
    method __init__ (line 113) | def __init__(self) -> None:
    method _get_text (line 116) | def _get_text(self, key: str) -> Optional[str]:
    method title (line 125) | def title(self) -> Optional[str]:
    method title_raw (line 139) | def title_raw(self) -> Optional[str]:
    method author (line 144) | def author(self) -> Optional[str]:
    method author_raw (line 154) | def author_raw(self) -> Optional[str]:
    method subject (line 159) | def subject(self) -> Optional[str]:
    method subject_raw (line 169) | def subject_raw(self) -> Optional[str]:
    method creator (line 174) | def creator(self) -> Optional[str]:
    method creator_raw (line 186) | def creator_raw(self) -> Optional[str]:
    method producer (line 191) | def producer(self) -> Optional[str]:
    method producer_raw (line 203) | def producer_raw(self) -> Optional[str]:
    method creation_date (line 208) | def creation_date(self) -> Optional[datetime]:
    method creation_date_raw (line 213) | def creation_date_raw(self) -> Optional[str]:
    method modification_date (line 223) | def modification_date(self) -> Optional[datetime]:
    method modification_date_raw (line 232) | def modification_date_raw(self) -> Optional[str]:
    method keywords (line 243) | def keywords(self) -> Optional[str]:
    method keywords_raw (line 253) | def keywords_raw(self) -> Optional[str]:
  class PdfDocCommon (line 258) | class PdfDocCommon:
    method root_object (line 275) | def root_object(self) -> DictionaryObject:
    method pdf_header (line 280) | def pdf_header(self) -> str:
    method get_object (line 284) | def get_object(
    method _replace_object (line 290) | def _replace_object(self, indirect: IndirectObject, obj: PdfObject) ->...
    method _info (line 295) | def _info(self) -> Optional[DictionaryObject]:
    method metadata (line 299) | def metadata(self) -> Optional[DocumentInformation]:
    method xmp_metadata (line 314) | def xmp_metadata(self) -> Optional[XmpInformation]:
    method viewer_preferences (line 318) | def viewer_preferences(self) -> Optional[ViewerPreferences]:
    method get_num_pages (line 332) | def get_num_pages(self) -> int:
    method get_page (line 353) | def get_page(self, page_number: int) -> PageObject:
    method _get_page_in_node (line 371) | def _get_page_in_node(
    method named_destinations (line 409) | def named_destinations(self) -> dict[str, Destination]:
    method get_named_dest_root (line 413) | def get_named_dest_root(self) -> ArrayObject:
    method _get_named_destinations (line 447) | def _get_named_destinations(
    method get_fields (line 523) | def get_fields(
    method _get_qualified_field_name (line 573) | def _get_qualified_field_name(self, parent: DictionaryObject) -> str:
    method _build_field (line 586) | def _build_field(
    method _check_kids (line 628) | def _check_kids(
    method _write_field (line 647) | def _write_field(self, fileobj: Any, field: Any, field_attributes: Any...
    method get_form_text_fields (line 684) | def get_form_text_fields(self, full_qualified_name: bool = False) -> d...
    method get_pages_showing_field (line 722) | def get_pages_showing_field(
    method open_destination (line 793) | def open_destination(
    method open_destination (line 823) | def open_destination(self, dest: Union[None, str, Destination, PageObj...
    method outline (line 827) | def outline(self) -> OutlineType:
    method _get_outline (line 835) | def _get_outline(
    method threads (line 894) | def threads(self) -> Optional[ArrayObject]:
    method _get_page_number_by_indirect (line 915) | def _get_page_number_by_indirect(
    method get_page_number (line 920) | def get_page_number(self, page: PageObject) -> Optional[int]:
    method get_destination_page_number (line 934) | def get_destination_page_number(self, destination: Destination) -> Opt...
    method _build_destination (line 947) | def _build_destination(
    method _build_outline_item (line 977) | def _build_outline_item(self, node: DictionaryObject) -> Optional[Dest...
    method pages (line 1055) | def pages(self) -> list[PageObject]:
    method page_labels (line 1072) | def page_labels(self) -> list[str]:
    method page_layout (line 1082) | def page_layout(self) -> Optional[str]:
    method page_mode (line 1110) | def page_mode(self) -> Optional[PagemodeType]:
    method _flatten (line 1135) | def _flatten(
    method remove_page (line 1220) | def remove_page(
    method _get_indirect_object (line 1264) | def _get_indirect_object(self, num: int, gen: int) -> Optional[PdfObje...
    method decode_permissions (line 1280) | def decode_permissions(
    method user_access_permissions (line 1308) | def user_access_permissions(self) -> Optional[UserAccessPermissions]:
    method are_permissions_valid (line 1325) | def are_permissions_valid(self) -> Optional[bool]:
    method is_encrypted (line 1346) | def is_encrypted(self) -> bool:
    method xfa (line 1356) | def xfa(self) -> Optional[dict[str, Any]]:
    method attachments (line 1379) | def attachments(self) -> Mapping[str, list[bytes]]:
    method attachment_list (line 1389) | def attachment_list(self) -> Generator[EmbeddedFile, None, None]:
    method _list_attachments (line 1393) | def _list_attachments(self) -> list[str]:
    method _get_attachment_list (line 1408) | def _get_attachment_list(self, name: str) -> list[bytes]:
    method _get_attachments (line 1414) | def _get_attachments(
    method _repr_mimebundle_ (line 1457) | def _repr_mimebundle_(
  class LazyDict (line 1475) | class LazyDict(Mapping[Any, Any]):
    method __init__ (line 1476) | def __init__(self, *args: Any, **kwargs: Any) -> None:
    method __getitem__ (line 1479) | def __getitem__(self, key: str) -> Any:
    method __iter__ (line 1483) | def __iter__(self) -> Iterator[Any]:
    method __len__ (line 1486) | def __len__(self) -> int:
    method __str__ (line 1489) | def __str__(self) -> str:

FILE: pypdf/_encryption.py
  class CryptFilter (line 60) | class CryptFilter:
    method __init__ (line 61) | def __init__(
    method encrypt_object (line 71) | def encrypt_object(self, obj: PdfObject) -> PdfObject:
    method decrypt_object (line 94) | def decrypt_object(self, obj: PdfObject) -> PdfObject:
  function _padding (line 117) | def _padding(data: bytes) -> bytes:
  class AlgV4 (line 121) | class AlgV4:
    method compute_key (line 123) | def compute_key(
    method compute_O_value_key (line 208) | def compute_O_value_key(owner_password: bytes, rev: int, key_size: int...
    method compute_O_value (line 259) | def compute_O_value(rc4_key: bytes, user_password: bytes, rev: int) ->...
    method compute_U_value (line 281) | def compute_U_value(key: bytes, rev: int, id1_entry: bytes) -> bytes:
    method verify_user_password (line 341) | def verify_user_password(
    method verify_owner_password (line 400) | def verify_owner_password(
  class AlgV5 (line 472) | class AlgV5:
    method verify_owner_password (line 474) | def verify_owner_password(
    method verify_user_password (line 546) | def verify_user_password(
    method calculate_hash (line 573) | def calculate_hash(R: int, password: bytes, salt: bytes, udata: bytes)...
    method verify_perms (line 594) | def verify_perms(
    method generate_values (line 621) | def generate_values(
    method compute_U_value (line 643) | def compute_U_value(R: int, password: bytes, key: bytes) -> tuple[byte...
    method compute_O_value (line 680) | def compute_O_value(
    method compute_Perms_value (line 726) | def compute_Perms_value(key: bytes, p: int, metadata_encrypted: bool) ...
  class PasswordType (line 764) | class PasswordType(IntEnum):
  class EncryptAlgorithm (line 770) | class EncryptAlgorithm(tuple, Enum):  # type: ignore # noqa: SLOT001
  class EncryptionValues (line 779) | class EncryptionValues:
  class Encryption (line 787) | class Encryption:
    method __init__ (line 812) | def __init__(
    method is_decrypted (line 843) | def is_decrypted(self) -> bool:
    method encrypt_object (line 846) | def encrypt_object(self, obj: PdfObject, idnum: int, generation: int) ...
    method decrypt_object (line 854) | def decrypt_object(self, obj: PdfObject, idnum: int, generation: int) ...
    method _is_encryption_object (line 863) | def _is_encryption_object(obj: PdfObject) -> bool:
    method _make_crypt_filter (line 875) | def _make_crypt_filter(self, idnum: int, generation: int) -> CryptFilter:
    method _get_crypt (line 939) | def _get_crypt(
    method _encode_password (line 952) | def _encode_password(password: Union[bytes, str]) -> bytes:
    method verify (line 962) | def verify(self, password: Union[bytes, str]) -> PasswordType:
    method verify_v4 (line 970) | def verify_v4(self, password: bytes) -> tuple[bytes, PasswordType]:
    method verify_v5 (line 998) | def verify_v5(self, password: bytes) -> tuple[bytes, PasswordType]:
    method write_entry (line 1019) | def write_entry(
    method compute_values_v4 (line 1071) | def compute_values_v4(self, user_password: bytes, owner_password: byte...
    method read (line 1091) | def read(encryption_entry: DictionaryObject, first_id_entry: bytes) ->...
    method make (line 1160) | def make(

FILE: pypdf/_font.py
  class FontDescriptor (line 14) | class FontDescriptor:
  class CoreFontMetrics (line 37) | class CoreFontMetrics:
  class Font (line 43) | class Font:
    method _collect_tt_t1_character_widths (line 72) | def _collect_tt_t1_character_widths(
    method _collect_cid_character_widths (line 104) | def _collect_cid_character_widths(
    method _add_default_width (line 177) | def _add_default_width(current_widths: dict[str, int], flags: int) -> ...
    method _parse_font_descriptor (line 196) | def _parse_font_descriptor(font_descriptor_obj: DictionaryObject) -> d...
    method from_font_resource (line 220) | def from_font_resource(
    method as_font_resource (line 305) | def as_font_resource(self) -> DictionaryObject:
    method text_width (line 317) | def text_width(self, text: str = "") -> float:

FILE: pypdf/_page.py
  function _get_rectangle (line 94) | def _get_rectangle(self: Any, name: str, defaults: Iterable[str]) -> Rec...
  function _set_rectangle (line 114) | def _set_rectangle(self: Any, name: str, value: Union[RectangleObject, f...
  function _delete_rectangle (line 118) | def _delete_rectangle(self: Any, name: str) -> None:
  function _create_rectangle_accessor (line 122) | def _create_rectangle_accessor(name: str, fallback: Iterable[str]) -> pr...
  class Transformation (line 130) | class Transformation:
    method __init__ (line 159) | def __init__(self, ctm: CompressedTransformationMatrix = (1, 0, 0, 1, ...
    method matrix (line 163) | def matrix(self) -> TransformationMatrixType:
    method compress (line 176) | def compress(matrix: TransformationMatrixType) -> CompressedTransforma...
    method _to_cm (line 196) | def _to_cm(self) -> str:
    method transform (line 203) | def transform(self, m: "Transformation") -> "Transformation":
    method translate (line 225) | def translate(self, tx: float = 0, ty: float = 0) -> "Transformation":
    method scale (line 240) | def scale(
    method rotate (line 269) | def rotate(self, rotation: float) -> "Transformation":
    method __repr__ (line 289) | def __repr__(self) -> str:
    method apply_on (line 293) | def apply_on(self, pt: list[float], as_object: bool = False) -> list[f...
    method apply_on (line 297) | def apply_on(
    method apply_on (line 302) | def apply_on(
  class ImageFile (line 327) | class ImageFile:
    method replace (line 354) | def replace(self, new_image: Image, **kwargs: Any) -> None:
    method __str__ (line 411) | def __str__(self) -> str:
    method __repr__ (line 414) | def __repr__(self) -> str:
  class VirtualListImages (line 418) | class VirtualListImages(Sequence[ImageFile]):
    method __init__ (line 425) | def __init__(
    method __len__ (line 434) | def __len__(self) -> int:
    method keys (line 437) | def keys(self) -> list[Union[str, list[str]]]:
    method items (line 440) | def items(self) -> list[tuple[Union[str, list[str]], ImageFile]]:
    method __getitem__ (line 444) | def __getitem__(self, index: Union[int, str, list[str]]) -> ImageFile:
    method __getitem__ (line 448) | def __getitem__(self, index: slice) -> Sequence[ImageFile]:
    method __getitem__ (line 451) | def __getitem__(
    method __iter__ (line 472) | def __iter__(self) -> Iterator[ImageFile]:
    method __str__ (line 476) | def __str__(self) -> str:
  class PageObject (line 481) | class PageObject(DictionaryObject):
    method __init__ (line 500) | def __init__(
    method hash_bin (line 514) | def hash_bin(self) -> int:
    method hash_value_data (line 529) | def hash_value_data(self) -> bytes:
    method user_unit (line 535) | def user_unit(self) -> float:
    method create_blank_page (line 546) | def create_blank_page(
    method _get_ids_image (line 591) | def _get_ids_image(
    method _get_image (line 629) | def _get_image(
    method images (line 674) | def images(self) -> VirtualListImages:
    method _translate_value_inline_image (line 713) | def _translate_value_inline_image(self, k: str, v: PdfObject) -> PdfOb...
    method _get_inline_images (line 728) | def _get_inline_images(self) -> dict[str, ImageFile]:
    method rotation (line 775) | def rotation(self) -> int:
    method rotation (line 786) | def rotation(self, r: float) -> None:
    method transfer_rotation_to_content (line 789) | def transfer_rotation_to_content(self) -> None:
    method rotate (line 824) | def rotate(self, angle: int) -> "PageObject":
    method _merge_resources (line 840) | def _merge_resources(
    method _content_stream_rename (line 922) | def _content_stream_rename(
    method _add_transformation_matrix (line 944) | def _add_transformation_matrix(
    method _get_contents_as_bytes (line 960) | def _get_contents_as_bytes(self) -> Optional[bytes]:
    method get_contents (line 975) | def get_contents(self) -> Optional[ContentStream]:
    method replace_contents (line 996) | def replace_contents(
    method merge_page (line 1059) | def merge_page(
    method _merge_page (line 1081) | def _merge_page(
    method _merge_page_writer (line 1188) | def _merge_page_writer(
    method _expand_mediabox (line 1326) | def _expand_mediabox(
    method merge_transformed_page (line 1369) | def merge_transformed_page(
    method merge_scaled_page (line 1401) | def merge_scaled_page(
    method merge_rotated_page (line 1419) | def merge_rotated_page(
    method merge_translated_page (line 1441) | def merge_translated_page(
    method add_transformation (line 1465) | def add_transformation(
    method scale (line 1515) | def scale(self, sx: float, sy: float) -> None:
    method scale_by (line 1569) | def scale_by(self, factor: float) -> None:
    method scale_to (line 1580) | def scale_to(self, width: float, height: float) -> None:
    method compress_content_streams (line 1594) | def compress_content_streams(self, level: int = -1) -> None:
    method page_number (line 1618) | def page_number(self) -> Optional[int]:
    method _debug_for_extract (line 1634) | def _debug_for_extract(self) -> str:  # pragma: no cover
    method _extract_text (line 1672) | def _extract_text(
    method _layout_mode_fonts (line 1835) | def _layout_mode_fonts(self) -> dict[str, Font]:
    method _layout_mode_text (line 1861) | def _layout_mode_text(
    method extract_text (line 1920) | def extract_text(
    method extract_xform_text (line 2056) | def extract_xform_text(
    method _get_fonts (line 2091) | def _get_fonts(self) -> tuple[set[str], set[str]]:
    method annotations (line 2140) | def annotations(self) -> Optional[ArrayObject]:
    method annotations (line 2146) | def annotations(self, value: Optional[ArrayObject]) -> None:
  class _VirtualList (line 2162) | class _VirtualList(Sequence[PageObject]):
    method __init__ (line 2163) | def __init__(
    method __len__ (line 2172) | def __len__(self) -> int:
    method __getitem__ (line 2176) | def __getitem__(self, index: int) -> PageObject:
    method __getitem__ (line 2180) | def __getitem__(self, index: slice) -> Sequence[PageObject]:
    method __getitem__ (line 2183) | def __getitem__(
    method __delitem__ (line 2200) | def __delitem__(self, index: Union[int, slice]) -> None:
    method __iter__ (line 2247) | def __iter__(self) -> Iterator[PageObject]:
    method __str__ (line 2251) | def __str__(self) -> str:
  function _get_fonts_walk (line 2256) | def _get_fonts_walk(

FILE: pypdf/_page_labels.py
  function number2uppercase_roman_numeral (line 75) | def number2uppercase_roman_numeral(num: int) -> str:
  function number2lowercase_roman_numeral (line 103) | def number2lowercase_roman_numeral(number: int) -> str:
  function number2uppercase_letter (line 107) | def number2uppercase_letter(number: int) -> str:
  function number2lowercase_letter (line 123) | def number2lowercase_letter(number: int) -> str:
  function get_label_from_nums (line 127) | def get_label_from_nums(dictionary_object: DictionaryObject, index: int)...
  function index2label (line 164) | def index2label(reader: PdfCommonDocProtocol, index: int) -> str:
  function nums_insert (line 213) | def nums_insert(
  function nums_clear_range (line 243) | def nums_clear_range(
  function nums_next (line 270) | def nums_next(

FILE: pypdf/_protocols.py
  class PdfObjectProtocol (line 10) | class PdfObjectProtocol(Protocol):
    method clone (line 13) | def clone(
    method _reference_clone (line 21) | def _reference_clone(self, clone: Any, pdf_dest: Any) -> Any:
    method get_object (line 24) | def get_object(self) -> Optional["PdfObjectProtocol"]:
    method hash_value (line 27) | def hash_value(self) -> bytes:
    method write_to_stream (line 30) | def write_to_stream(
  class XmpInformationProtocol (line 36) | class XmpInformationProtocol(PdfObjectProtocol):
  class PdfCommonDocProtocol (line 40) | class PdfCommonDocProtocol(Protocol):
    method pdf_header (line 42) | def pdf_header(self) -> str:
    method pages (line 46) | def pages(self) -> list[Any]:
    method root_object (line 50) | def root_object(self) -> PdfObjectProtocol:
    method get_object (line 53) | def get_object(self, indirect_reference: Any) -> Optional[PdfObjectPro...
    method strict (line 57) | def strict(self) -> bool:
  class PdfReaderProtocol (line 61) | class PdfReaderProtocol(PdfCommonDocProtocol, Protocol):
    method xref (line 64) | def xref(self) -> dict[int, dict[int, Any]]:
    method trailer (line 69) | def trailer(self) -> dict[str, Any]:
  class PdfWriterProtocol (line 73) | class PdfWriterProtocol(PdfCommonDocProtocol, Protocol):
    method write (line 81) | def write(self, stream: Union[Path, StrByteType]) -> tuple[bool, IO[An...
    method _add_object (line 85) | def _add_object(self, obj: Any) -> Any:

FILE: pypdf/_reader.py
  class PdfReader (line 95) | class PdfReader(PdfDocCommon):
    method __init__ (line 118) | def __init__(
    method _initialize_stream (line 159) | def _initialize_stream(self, stream: Union[StrByteType, Path]) -> None:
    method _handle_encryption (line 174) | def _handle_encryption(self, password: Optional[Union[str, bytes]]) ->...
    method __enter__ (line 194) | def __enter__(self) -> Self:
    method __exit__ (line 197) | def __exit__(
    method close (line 205) | def close(self) -> None:
    method root_object (line 217) | def root_object(self) -> DictionaryObject:
    method _info (line 261) | def _info(self) -> Optional[DictionaryObject]:
    method _ID (line 281) | def _ID(self) -> Optional[ArrayObject]:
    method pdf_header (line 296) | def pdf_header(self) -> str:
    method xmp_metadata (line 312) | def xmp_metadata(self) -> Optional[XmpInformation]:
    method _get_page_number_by_indirect (line 320) | def _get_page_number_by_indirect(
    method _get_object_from_stream (line 348) | def _get_object_from_stream(
    method get_object (line 427) | def get_object(
    method read_object_header (line 577) | def read_object_header(self, stream: StreamType) -> tuple[int, int]:
    method cache_get_indirect_object (line 604) | def cache_get_indirect_object(
    method cache_indirect_object (line 612) | def cache_indirect_object(
    method _replace_object (line 625) | def _replace_object(self, indirect_reference: IndirectObject, obj: Pdf...
    method read (line 635) | def read(self, stream: StreamType) -> None:
    method _basic_validation (line 701) | def _basic_validation(self, stream: StreamType) -> None:
    method _find_eof_marker (line 719) | def _find_eof_marker(self, stream: StreamType) -> None:
    method _find_startxref_pos (line 752) | def _find_startxref_pos(self, stream: StreamType) -> int:
    method _read_standard_xref_table (line 778) | def _read_standard_xref_table(self, stream: StreamType) -> None:
    method _read_xref_tables_and_trailers (line 898) | def _read_xref_tables_and_trailers(
    method _process_xref_stream (line 947) | def _process_xref_stream(self, xrefstream: DictionaryObject) -> None:
    method _read_xref (line 959) | def _read_xref(self, stream: StreamType) -> Optional[int]:
    method _read_xref_other_error (line 985) | def _read_xref_other_error(
    method _read_pdf15_xref_stream (line 1026) | def _read_pdf15_xref_stream(
    method _get_xref_issues (line 1073) | def _get_xref_issues(stream: StreamType, startxref: int) -> int:
    method _find_pdf_objects (line 1108) | def _find_pdf_objects(cls, data: bytes) -> Iterable[tuple[int, int, in...
    method _find_pdf_trailers (line 1149) | def _find_pdf_trailers(cls, data: bytes) -> Iterable[int]:
    method _rebuild_xref_table (line 1169) | def _rebuild_xref_table(self, stream: StreamType) -> None:
    method _read_xref_subsections (line 1221) | def _read_xref_subsections(
    method _pairs (line 1256) | def _pairs(self, array: list[int]) -> Iterable[tuple[int, int]]:
    method decrypt (line 1263) | def decrypt(self, password: Union[str, bytes]) -> PasswordType:
    method is_encrypted (line 1289) | def is_encrypted(self) -> bool:
    method add_form_topname (line 1298) | def add_form_topname(self, name: str) -> Optional[DictionaryObject]:
    method rename_form_topname (line 1341) | def rename_form_topname(self, name: str) -> Optional[DictionaryObject]:
    method _repr_mimebundle_ (line 1369) | def _repr_mimebundle_(

FILE: pypdf/_text_extraction/__init__.py
  class OrientationNotFoundError (line 19) | class OrientationNotFoundError(Exception):
  function set_custom_rtl (line 23) | def set_custom_rtl(
  function mult (line 69) | def mult(m: list[float], n: list[float]) -> list[float]:
  function orient (line 80) | def orient(m: list[float]) -> int:
  function crlf_space_check (line 90) | def crlf_space_check(
  function get_text_operands (line 155) | def get_text_operands(
  function get_display_str (line 195) | def get_display_str(

FILE: pypdf/_text_extraction/_layout_mode/_fixed_width_page.py
  class BTGroup (line 16) | class BTGroup(TypedDict):
  function bt_group (line 41) | def bt_group(tj_op: TextStateParams, rendered_text: str, dispaced_tx: fl...
  function recurs_to_target_op (line 63) | def recurs_to_target_op(
  function y_coordinate_groups (line 208) | def y_coordinate_groups(
  function text_show_operations (line 256) | def text_show_operations(
  function fixed_char_width (line 328) | def fixed_char_width(bt_groups: list[BTGroup], scale_weight: float = 1.2...
  function fixed_width_page (line 348) | def fixed_width_page(

FILE: pypdf/_text_extraction/_layout_mode/_text_state_manager.py
  class TextStateManager (line 18) | class TextStateManager:
    method __init__ (line 36) | def __init__(self) -> None:
    method set_state_param (line 51) | def set_state_param(self, op: bytes, value: Union[float, list[Any]]) -...
    method set_font (line 66) | def set_font(self, font: Font, size: float) -> None:
    method text_state_params (line 78) | def text_state_params(self, value: Union[bytes, str] = "") -> TextStat...
    method raw_transform (line 128) | def raw_transform(
    method new_transform (line 140) | def new_transform(
    method reset_tm (line 155) | def reset_tm(self) -> TextStateManagerChainMapType:
    method reset_trm (line 164) | def reset_trm(self) -> TextStateManagerChainMapType:
    method remove_q (line 170) | def remove_q(self) -> TextStateManagerChainMapType:
    method add_q (line 179) | def add_q(self) -> None:
    method add_cm (line 184) | def add_cm(self, *args: Any) -> TextStateManagerChainMapType:
    method _complete_matrix (line 191) | def _complete_matrix(self, operands: list[float]) -> list[float]:
    method add_tm (line 197) | def add_tm(self, operands: list[float]) -> TextStateManagerChainMapType:
    method add_trm (line 206) | def add_trm(self, operands: list[float]) -> TextStateManagerChainMapType:
    method effective_transform (line 216) | def effective_transform(self) -> list[float]:

FILE: pypdf/_text_extraction/_layout_mode/_text_state_params.py
  class TextStateParams (line 12) | class TextStateParams:
    method __post_init__ (line 56) | def __post_init__(self) -> None:
    method font_size_matrix (line 84) | def font_size_matrix(self) -> list[float]:
    method displaced_transform (line 95) | def displaced_transform(self) -> list[float]:
    method render_transform (line 99) | def render_transform(self) -> list[float]:
    method displacement_matrix (line 103) | def displacement_matrix(
    method word_tx (line 118) | def word_tx(self, word: str, td_offset: float = 0.0) -> float:
    method to_dict (line 133) | def to_dict(inst: "TextStateParams") -> dict[str, Any]:

FILE: pypdf/_text_extraction/_text_extractor.py
  class TextExtraction (line 38) | class TextExtraction:
    method __init__ (line 47) | def __init__(self) -> None:
    method initialize_extraction (line 115) | def initialize_extraction(
    method compute_str_widths (line 133) | def compute_str_widths(self, str_widths: float) -> float:
    method process_operation (line 136) | def process_operation(self, operator: bytes, operands: list[Any]) -> N...
    method _post_process_text_operation (line 145) | def _post_process_text_operation(self, str_widths: float) -> None:
    method _handle_tj (line 168) | def _handle_tj(
    method _flush_text (line 204) | def _flush_text(self) -> None:
    method _handle_bt (line 215) | def _handle_bt(self, operands: list[Any]) -> None:
    method _handle_et (line 220) | def _handle_et(self, operands: list[Any]) -> None:
    method _handle_save_graphics_state (line 224) | def _handle_save_graphics_state(self, operands: list[Any]) -> None:
    method _handle_restore_graphics_state (line 238) | def _handle_restore_graphics_state(self, operands: list[Any]) -> None:
    method _handle_cm (line 253) | def _handle_cm(self, operands: list[Any]) -> None:
    method _handle_tz (line 266) | def _handle_tz(self, operands: list[Any]) -> None:
    method _handle_tw (line 270) | def _handle_tw(self, operands: list[Any]) -> None:
    method _handle_tl (line 274) | def _handle_tl(self, operands: list[Any]) -> None:
    method _handle_tf (line 279) | def _handle_tf(self, operands: list[Any]) -> None:
    method _handle_td (line 308) | def _handle_td(self, operands: list[Any]) -> float:
    method _handle_tm (line 320) | def _handle_tm(self, operands: list[Any]) -> float:
    method _handle_t_star (line 327) | def _handle_t_star(self, operands: list[Any]) -> float:
    method _handle_tj_operation (line 335) | def _handle_tj_operation(self, operands: list[Any]) -> float:

FILE: pypdf/_utils.py
  function parse_iso8824_date (line 78) | def parse_iso8824_date(text: Optional[str]) -> Optional[datetime]:
  function format_iso8824_date (line 110) | def format_iso8824_date(dt: datetime) -> str:
  function _get_max_pdf_version_header (line 135) | def _get_max_pdf_version_header(header1: str, header2: str) -> str:
  function read_until_whitespace (line 159) | def read_until_whitespace(stream: StreamType, maxchars: Optional[int] = ...
  function read_non_whitespace (line 184) | def read_non_whitespace(stream: StreamType) -> bytes:
  function skip_over_whitespace (line 201) | def skip_over_whitespace(stream: StreamType) -> bool:
  function check_if_whitespace_only (line 221) | def check_if_whitespace_only(value: bytes) -> bool:
  function skip_over_comment (line 235) | def skip_over_comment(stream: StreamType) -> None:
  function read_until_regex (line 245) | def read_until_regex(stream: StreamType, regex: Pattern[bytes]) -> bytes:
  function read_block_backwards (line 285) | def read_block_backwards(stream: StreamType, to_read: int) -> bytes:
  function read_previous_line (line 310) | def read_previous_line(stream: StreamType) -> bytes:
  function matrix_multiply (line 368) | def matrix_multiply(
  function mark_location (line 377) | def mark_location(stream: StreamType) -> None:
  function ord_ (line 390) | def ord_(b: str) -> int:
  function ord_ (line 395) | def ord_(b: bytes) -> bytes:
  function ord_ (line 400) | def ord_(b: int) -> int:
  function ord_ (line 404) | def ord_(b: Union[int, str, bytes]) -> Union[int, bytes]:
  function deprecate (line 410) | def deprecate(msg: str, stacklevel: int = 3) -> None:
  function deprecation (line 414) | def deprecation(msg: str) -> None:
  function deprecate_with_replacement (line 418) | def deprecate_with_replacement(old_name: str, new_name: str, removed_in:...
  function deprecation_with_replacement (line 426) | def deprecation_with_replacement(old_name: str, new_name: str, removed_i...
  function deprecate_no_replacement (line 433) | def deprecate_no_replacement(name: str, removed_in: str) -> None:
  function deprecation_no_replacement (line 438) | def deprecation_no_replacement(name: str, removed_in: str) -> None:
  function logger_error (line 443) | def logger_error(message: str, *, source: str, **values: Any) -> None:
  function logger_warning (line 455) | def logger_warning(msg: str, src: str) -> None:
  function rename_kwargs (line 474) | def rename_kwargs(
  function _human_readable_bytes (line 509) | def _human_readable_bytes(bytes: int) -> str:
  class classproperty (line 554) | class classproperty:  # noqa: N801
    method __init__ (line 560) | def __init__(self, method=None) -> None:  # type: ignore  # noqa: ANN001
    method __get__ (line 563) | def __get__(self, instance, cls=None) -> Any:  # type: ignore  # noqa:...
    method getter (line 566) | def getter(self, method) -> Self:  # type: ignore  # noqa: ANN001
  class File (line 572) | class File:
    method __str__ (line 588) | def __str__(self) -> str:
    method __repr__ (line 591) | def __repr__(self) -> str:
  class Version (line 596) | class Version:
    method __init__ (line 599) | def __init__(self, version_str: str) -> None:
    method _parse_version (line 603) | def _parse_version(self, version_str: str) -> list[tuple[int, str]]:
    method __eq__ (line 618) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 623) | def __hash__(self) -> int:
    method __lt__ (line 627) | def __lt__(self, other: Any) -> bool:

FILE: pypdf/_writer.py
  class ObjectDeletionFlag (line 129) | class ObjectDeletionFlag(enum.IntFlag):
  function _rolling_checksum (line 142) | def _rolling_checksum(stream: BytesIO, blocksize: int = 65536) -> str:
  class PdfWriter (line 149) | class PdfWriter(PdfDocCommon):
    method __init__ (line 173) | def __init__(
    method is_encrypted (line 313) | def is_encrypted(self) -> bool:
    method root_object (line 323) | def root_object(self) -> DictionaryObject:
    method _info (line 334) | def _info(self) -> Optional[DictionaryObject]:
    method _info (line 349) | def _info(self, value: Optional[Union[IndirectObject, DictionaryObject...
    method xmp_metadata (line 364) | def xmp_metadata(self) -> Optional[XmpInformation]:
    method xmp_metadata (line 369) | def xmp_metadata(self, value: Union[XmpInformation, bytes, None]) -> N...
    method with_as_usage (line 393) | def with_as_usage(self) -> bool:
    method with_as_usage (line 398) | def with_as_usage(self, value: bool) -> None:
    method __enter__ (line 402) | def __enter__(self) -> Self:
    method __exit__ (line 412) | def __exit__(
    method pdf_header (line 423) | def pdf_header(self) -> str:
    method pdf_header (line 436) | def pdf_header(self, new_header: Union[str, bytes]) -> None:
    method _add_object (line 441) | def _add_object(self, obj: PdfObject) -> IndirectObject:
    method get_object (line 456) | def get_object(
    method _replace_object (line 469) | def _replace_object(
    method _add_page (line 490) | def _add_page(
    method set_need_appearances_writer (line 548) | def set_need_appearances_writer(self, state: bool = True) -> None:
    method create_viewer_preferences (line 581) | def create_viewer_preferences(self) -> ViewerPreferences:
    method add_page (line 588) | def add_page(
    method insert_page (line 613) | def insert_page(
    method _get_page_number_by_indirect (line 641) | def _get_page_number_by_indirect(
    method add_blank_page (line 665) | def add_blank_page(
    method insert_blank_page (line 690) | def insert_blank_page(
    method open_destination (line 731) | def open_destination(
    method open_destination (line 737) | def open_destination(self, dest: Union[None, str, Destination, PageObj...
    method add_js (line 756) | def add_js(self, javascript: str) -> None:
    method add_attachment (line 795) | def add_attachment(self, filename: str, data: Union[str, bytes]) -> "E...
    method append_pages_from_reader (line 813) | def append_pages_from_reader(
    method _merge_content_stream_to_page (line 845) | def _merge_content_stream_to_page(
    method _add_apstream_object (line 884) | def _add_apstream_object(
    method update_page_form_field_values (line 939) | def update_page_form_field_values(
    method reattach_fields (line 1080) | def reattach_fields(
    method clone_reader_document_root (line 1130) | def clone_reader_document_root(self, reader: PdfReader) -> None:
    method clone_document_from_reader (line 1183) | def clone_document_from_reader(
    method _compute_document_identifier (line 1231) | def _compute_document_identifier(self) -> ByteStringObject:
    method generate_file_identifiers (line 1237) | def generate_file_identifiers(self) -> None:
    method encrypt (line 1257) | def encrypt(
    method _resolve_links (line 1316) | def _resolve_links(self) -> None:
    method write_stream (line 1329) | def write_stream(self, stream: StreamType) -> None:
    method write (line 1350) | def write(self, stream: Union[Path, StrByteType]) -> tuple[bool, IO[An...
    method list_objects_in_increment (line 1382) | def list_objects_in_increment(self) -> list[IndirectObject]:
    method _write_increment (line 1406) | def _write_increment(self, stream: StreamType) -> None:
    method _write_pdf_structure (line 1477) | def _write_pdf_structure(self, stream: StreamType) -> tuple[list[int],...
    method _write_xref_table (line 1497) | def _write_xref_table(
    method _write_trailer (line 1513) | def _write_trailer(self, stream: StreamType, xref_location: int) -> None:
    method metadata (line 1538) | def metadata(self) -> Optional[DocumentInformation]:
    method metadata (line 1553) | def metadata(
    method add_metadata (line 1565) | def add_metadata(self, infos: dict[str, Any]) -> None:
    method compress_identical_objects (line 1585) | def compress_identical_objects(
    method get_reference (line 1661) | def get_reference(self, obj: PdfObject) -> IndirectObject:
    method get_outline_root (line 1667) | def get_outline_root(self) -> TreeObject:
    method get_threads_root (line 1686) | def get_threads_root(self) -> ArrayObject:
    method threads (line 1706) | def threads(self) -> ArrayObject:
    method add_outline_item_destination (line 1717) | def add_outline_item_destination(
    method add_outline_item_dict (line 1755) | def add_outline_item_dict(
    method add_outline_item (line 1778) | def add_outline_item(
    method add_outline (line 1856) | def add_outline(self) -> None:
    method add_named_destination_array (line 1861) | def add_named_destination_array(
    method add_named_destination_object (line 1875) | def add_named_destination_object(
    method add_named_destination (line 1886) | def add_named_destination(
    method remove_links (line 1909) | def remove_links(self) -> None:
    method remove_annotations (line 1914) | def remove_annotations(
    method _remove_annots_from_page (line 1930) | def _remove_annots_from_page(
    method remove_objects_from_page (line 1948) | def remove_objects_from_page(
    method _remove_objects_from_page__clean (line 2013) | def _remove_objects_from_page__clean(
    method _remove_objects_from_page__clean_forms (line 2056) | def _remove_objects_from_page__clean_forms(
    method remove_images (line 2139) | def remove_images(
    method remove_text (line 2163) | def remove_text(self, font_names: Optional[list[str]] = None) -> None:
    method add_uri (line 2220) | def add_uri(
    method _get_page_layout (line 2297) | def _get_page_layout(self) -> Optional[LayoutType]:
    method _set_page_layout (line 2303) | def _set_page_layout(self, layout: Union[NameObject, LayoutType]) -> N...
    method set_page_layout (line 2338) | def set_page_layout(self, layout: LayoutType) -> None:
    method page_layout (line 2367) | def page_layout(self) -> Optional[LayoutType]:
    method page_layout (line 2392) | def page_layout(self, layout: LayoutType) -> None:
    method _get_page_mode (line 2404) | def _get_page_mode(self) -> Optional[PagemodeType]:
    method page_mode (line 2411) | def page_mode(self) -> Optional[PagemodeType]:
    method page_mode (line 2434) | def page_mode(self, mode: PagemodeType) -> None:
    method add_annotation (line 2445) | def add_annotation(
    method clean_page (line 2499) | def clean_page(self, page: Union[PageObject, IndirectObject]) -> PageO...
    method _create_stream (line 2526) | def _create_stream(
    method append (line 2562) | def append(
    method merge (line 2630) | def merge(
    method _merge__process_named_dests (line 2786) | def _merge__process_named_dests(self, dest: Any, reader: PdfDocCommon,...
    method _add_articles_thread (line 2820) | def _add_articles_thread(
    method add_filtered_articles (line 2885) | def add_filtered_articles(
    method _get_cloned_page (line 2921) | def _get_cloned_page(
    method _insert_filtered_annotations (line 2938) | def _insert_filtered_annotations(
    method _get_filtered_outline (line 2995) | def _get_filtered_outline(
    method _clone_outline (line 3047) | def _clone_outline(self, dest: Destination) -> TreeObject:
    method _insert_filtered_outline (line 3066) | def _insert_filtered_outline(
    method close (line 3082) | def close(self) -> None:
    method find_outline_item (line 3086) | def find_outline_item(
    method reset_translation (line 3116) | def reset_translation(
    method set_page_label (line 3144) | def set_page_label(
    method _set_page_label (line 3195) | def _set_page_label(
    method _repr_mimebundle_ (line 3260) | def _repr_mimebundle_(
  function _pdf_objectify (line 3292) | def _pdf_objectify(obj: Union[dict[str, Any], str, float, list[Any]]) ->...
  function _create_outline_item (line 3313) | def _create_outline_item(

FILE: pypdf/annotations/_base.py
  class AnnotationDictionary (line 8) | class AnnotationDictionary(DictionaryObject, ABC):
    method __init__ (line 9) | def __init__(self) -> None:
    method flags (line 21) | def flags(self) -> AnnotationFlag:
    method flags (line 25) | def flags(self, value: AnnotationFlag) -> None:

FILE: pypdf/annotations/_markup_annotations.py
  function _get_bounding_rectangle (line 31) | def _get_bounding_rectangle(vertices: list[Vertex]) -> RectangleObject:
  class MarkupAnnotation (line 42) | class MarkupAnnotation(AnnotationDictionary, ABC):
    method __init__ (line 65) | def __init__(
  class Text (line 101) | class Text(MarkupAnnotation):
    method __init__ (line 114) | def __init__(
  class FreeText (line 131) | class FreeText(MarkupAnnotation):
    method __init__ (line 134) | def __init__(
  class Line (line 195) | class Line(MarkupAnnotation):
    method __init__ (line 196) | def __init__(
  class PolyLine (line 235) | class PolyLine(MarkupAnnotation):
    method __init__ (line 236) | def __init__(
  class Rectangle (line 257) | class Rectangle(MarkupAnnotation):
    method __init__ (line 258) | def __init__(
  class Highlight (line 280) | class Highlight(MarkupAnnotation):
    method __init__ (line 281) | def __init__(
  class Ellipse (line 305) | class Ellipse(MarkupAnnotation):
    method __init__ (line 306) | def __init__(
  class Polygon (line 329) | class Polygon(MarkupAnnotation):
    method __init__ (line 330) | def __init__(

FILE: pypdf/annotations/_non_markup_annotations.py
  class Link (line 15) | class Link(AnnotationDictionary):
    method __init__ (line 16) | def __init__(
  class Popup (line 79) | class Popup(AnnotationDictionary):
    method __init__ (line 80) | def __init__(

FILE: pypdf/constants.py
  class StrEnum (line 6) | class StrEnum(str, Enum):  # Once we are on Python 3.11+: enum.StrEnum
    method __str__ (line 7) | def __str__(self) -> str:
  class Core (line 11) | class Core:
  class TrailerKeys (line 21) | class TrailerKeys:
  class CatalogAttributes (line 30) | class CatalogAttributes:
  class EncryptionDictAttributes (line 35) | class EncryptionDictAttributes:
  class UserAccessPermissions (line 50) | class UserAccessPermissions(IntFlag):
    method _is_reserved (line 90) | def _is_reserved(cls, name: str) -> bool:
    method _is_active (line 95) | def _is_active(cls, name: str) -> bool:
    method to_dict (line 99) | def to_dict(self) -> dict[str, bool]:
    method from_dict (line 109) | def from_dict(cls, value: dict[str, bool]) -> "UserAccessPermissions":
    method all (line 127) | def all(cls) -> "UserAccessPermissions":
  class Resources (line 131) | class Resources:
  class PagesAttributes (line 147) | class PagesAttributes:
  class PageAttributes (line 158) | class PageAttributes:
  class FileSpecificationDictionaryEntries (line 198) | class FileSpecificationDictionaryEntries:
  class StreamAttributes (line 216) | class StreamAttributes:
  class FilterTypes (line 228) | class FilterTypes(StrEnum):
  class FilterTypeAbbreviations (line 242) | class FilterTypeAbbreviations:
  class LzwFilterParameters (line 254) | class LzwFilterParameters:
  class CcittFaxDecodeParameters (line 267) | class CcittFaxDecodeParameters:
  class ImageAttributes (line 283) | class ImageAttributes:
  class ColorSpaces (line 301) | class ColorSpaces:
  class TypArguments (line 307) | class TypArguments:
  class TypFitArguments (line 316) | class TypFitArguments:
  class GoToActionArguments (line 329) | class GoToActionArguments:
  class AnnotationDictionaryAttributes (line 335) | class AnnotationDictionaryAttributes:
  class InteractiveFormDictEntries (line 355) | class InteractiveFormDictEntries:
  class FieldDictionaryAttributes (line 366) | class FieldDictionaryAttributes:
    class FfBits (line 386) | class FfBits(IntFlag):
    method attributes (line 445) | def attributes(cls) -> tuple[str, ...]:
    method attributes_dict (line 472) | def attributes_dict(cls) -> dict[str, str]:
  class CheckboxRadioButtonAttributes (line 498) | class CheckboxRadioButtonAttributes:
    method attributes (line 504) | def attributes(cls) -> tuple[str, ...]:
    method attributes_dict (line 520) | def attributes_dict(cls) -> dict[str, str]:
  class FieldFlag (line 539) | class FieldFlag(IntFlag):
  class DocumentInformationAttributes (line 547) | class DocumentInformationAttributes:
  class PageLayouts (line 561) | class PageLayouts:
  class GraphicsStateParameters (line 575) | class GraphicsStateParameters:
  class CatalogDictionary (line 607) | class CatalogDictionary:
  class OutlineFontFlag (line 644) | class OutlineFontFlag(IntFlag):
  class PageLabelStyle (line 651) | class PageLabelStyle:
  class AnnotationFlag (line 664) | class AnnotationFlag(IntFlag):
  class ImageType (line 709) | class ImageType(IntFlag):
  class AFRelationship (line 767) | class AFRelationship:
  class BorderStyles (line 785) | class BorderStyles:
  class FontFlags (line 799) | class FontFlags(IntFlag):

FILE: pypdf/errors.py
  class DeprecationError (line 8) | class DeprecationError(Exception):
  class DependencyError (line 12) | class DependencyError(Exception):
  class PyPdfError (line 19) | class PyPdfError(Exception):
  class PdfReadError (line 23) | class PdfReadError(PyPdfError):
  class PageSizeNotDefinedError (line 27) | class PageSizeNotDefinedError(PyPdfError):
  class PdfReadWarning (line 31) | class PdfReadWarning(UserWarning):
  class PdfStreamError (line 35) | class PdfStreamError(PdfReadError):
  class ParseError (line 39) | class ParseError(PyPdfError):
  class FileNotDecryptedError (line 46) | class FileNotDecryptedError(PdfReadError):
  class WrongPasswordError (line 54) | class WrongPasswordError(FileNotDecryptedError):
  class EmptyFileError (line 58) | class EmptyFileError(PdfReadError):
  class EmptyImageDataError (line 62) | class EmptyImageDataError(PyPdfError):
  class LimitReachedError (line 69) | class LimitReachedError(PyPdfError):
  class XmpDocumentError (line 73) | class XmpDocumentError(PyPdfError, RuntimeError):

FILE: pypdf/filters.py
  function _decompress_with_limit (line 88) | def _decompress_with_limit(data: bytes) -> bytes:
  function decompress (line 98) | def decompress(data: bytes) -> bytes:
  class FlateDecode (line 169) | class FlateDecode:
    method decode (line 171) | def decode(
    method _get_parameters (line 227) | def _get_parameters(parameters: DictionaryObject) -> tuple[int, int, i...
    method _decode_png_prediction (line 241) | def _decode_png_prediction(data: bytes, columns: int, rowlength: int) ...
    method encode (line 305) | def encode(data: bytes, level: int = -1) -> bytes:
  class ASCIIHexDecode (line 320) | class ASCIIHexDecode:
    method decode (line 327) | def decode(
  class RunLengthDecode (line 372) | class RunLengthDecode:
    method decode (line 387) | def decode(
  class LZWDecode (line 449) | class LZWDecode:
    class Decoder (line 450) | class Decoder:
      method __init__ (line 454) | def __init__(self, data: bytes) -> None:
      method decode (line 457) | def decode(self) -> bytes:
    method decode (line 461) | def decode(
  class ASCII85Decode (line 481) | class ASCII85Decode:
    method decode (line 485) | def decode(
  class DCTDecode (line 515) | class DCTDecode:
    method decode (line 517) | def decode(
  class JPXDecode (line 538) | class JPXDecode:
    method decode (line 540) | def decode(
  class CCITTParameters (line 561) | class CCITTParameters:
    method group (line 574) | def group(self) -> int:
  function __create_old_class_instance (line 585) | def __create_old_class_instance(
  class CCITTFaxDecode (line 598) | class CCITTFaxDecode:
    method _get_parameters (line 609) | def _get_parameters(
    method decode (line 636) | def decode(
  class JBIG2Decode (line 695) | class JBIG2Decode:
    method decode (line 697) | def decode(
    method _is_binary_compatible (line 750) | def _is_binary_compatible() -> bool:
  function _deprecate_inline_image_filters (line 764) | def _deprecate_inline_image_filters(filter_name: str, old_name: str, new...
  function decode_stream_data (line 773) | def decode_stream_data(stream: StreamObject) -> bytes:

FILE: pypdf/generic/_appearance_stream.py
  class BaseStreamConfig (line 24) | class BaseStreamConfig:
  class BaseStreamAppearance (line 31) | class BaseStreamAppearance(DecodedStreamObject):
    method __init__ (line 34) | def __init__(self, layout: Optional[BaseStreamConfig] = None) -> None:
  class TextAlignment (line 48) | class TextAlignment(IntEnum):
  class TextStreamAppearance (line 56) | class TextStreamAppearance(BaseStreamAppearance):
    method _scale_text (line 65) | def _scale_text(
    method _generate_appearance_stream_data (line 143) | def _generate_appearance_stream_data(
    method __init__ (line 305) | def __init__(
    method _find_annotation_font_resource (line 420) | def _find_annotation_font_resource(
    method from_text_annotation (line 458) | def from_text_annotation(

FILE: pypdf/generic/_base.py
  class PdfObject (line 64) | class PdfObject(PdfObjectProtocol):
    method hash_bin (line 69) | def hash_bin(self) -> int:
    method hash_value_data (line 81) | def hash_value_data(self) -> bytes:
    method hash_value (line 84) | def hash_value(self) -> bytes:
    method replicate (line 90) | def replicate(
    method clone (line 107) | def clone(
    method _reference_clone (line 138) | def _reference_clone(
    method get_object (line 196) | def get_object(self) -> Optional["PdfObject"]:
    method write_to_stream (line 200) | def write_to_stream(
  class NullObject (line 206) | class NullObject(PdfObject):
    method clone (line 207) | def clone(
    method hash_bin (line 218) | def hash_bin(self) -> int:
    method write_to_stream (line 228) | def write_to_stream(
    method read_from_stream (line 238) | def read_from_stream(stream: StreamType) -> "NullObject":
    method __repr__ (line 244) | def __repr__(self) -> str:
    method __eq__ (line 247) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 250) | def __hash__(self) -> int:
  class BooleanObject (line 254) | class BooleanObject(PdfObject):
    method __init__ (line 255) | def __init__(self, value: Any) -> None:
    method clone (line 258) | def clone(
    method hash_bin (line 270) | def hash_bin(self) -> int:
    method __eq__ (line 280) | def __eq__(self, o: object, /) -> bool:
    method __hash__ (line 287) | def __hash__(self) -> int:
    method __repr__ (line 290) | def __repr__(self) -> str:
    method write_to_stream (line 293) | def write_to_stream(
    method read_from_stream (line 306) | def read_from_stream(stream: StreamType) -> "BooleanObject":
  class IndirectObject (line 316) | class IndirectObject(PdfObject):
    method __init__ (line 317) | def __init__(self, idnum: int, generation: int, pdf: Any) -> None:  # ...
    method __hash__ (line 322) | def __hash__(self) -> int:
    method hash_bin (line 325) | def hash_bin(self) -> int:
    method replicate (line 335) | def replicate(
    method clone (line 341) | def clone(
    method indirect_reference (line 378) | def indirect_reference(self) -> "IndirectObject":  # type: ignore[over...
    method get_object (line 381) | def get_object(self) -> Optional["PdfObject"]:
    method __deepcopy__ (line 384) | def __deepcopy__(self, memo: Any) -> "IndirectObject":
    method _get_object_with_check (line 387) | def _get_object_with_check(self) -> Optional["PdfObject"]:
    method __getattr__ (line 396) | def __getattr__(self, name: str) -> Any:
    method __getitem__ (line 405) | def __getitem__(self, key: Any) -> Any:
    method __contains__ (line 409) | def __contains__(self, key: Any) -> bool:
    method __iter__ (line 412) | def __iter__(self) -> Any:
    method __float__ (line 415) | def __float__(self) -> str:
    method __int__ (line 419) | def __int__(self) -> int:
    method __str__ (line 423) | def __str__(self) -> str:
    method __repr__ (line 427) | def __repr__(self) -> str:
    method __eq__ (line 430) | def __eq__(self, other: object) -> bool:
    method __ne__ (line 439) | def __ne__(self, other: object) -> bool:
    method write_to_stream (line 442) | def write_to_stream(
    method read_from_stream (line 452) | def read_from_stream(stream: StreamType, pdf: Any) -> "IndirectObject"...
  class FloatObject (line 482) | class FloatObject(float, PdfObject):
    method __new__ (line 483) | def __new__(
    method clone (line 497) | def clone(
    method hash_bin (line 509) | def hash_bin(self) -> int:
    method myrepr (line 519) | def myrepr(self) -> str:
    method __repr__ (line 525) | def __repr__(self) -> str:
    method as_numeric (line 528) | def as_numeric(self) -> float:
    method write_to_stream (line 531) | def write_to_stream(
  class NumberObject (line 541) | class NumberObject(int, PdfObject):
    method __new__ (line 544) | def __new__(cls, value: Any) -> Self:
    method clone (line 551) | def clone(
    method hash_bin (line 563) | def hash_bin(self) -> int:
    method as_numeric (line 573) | def as_numeric(self) -> int:
    method write_to_stream (line 576) | def write_to_stream(
    method read_from_stream (line 586) | def read_from_stream(stream: StreamType) -> Union["NumberObject", "Flo...
  class ByteStringObject (line 593) | class ByteStringObject(bytes, PdfObject):
    method clone (line 602) | def clone(
    method hash_bin (line 616) | def hash_bin(self) -> int:
    method original_bytes (line 627) | def original_bytes(self) -> bytes:
    method write_to_stream (line 631) | def write_to_stream(
    method __str__ (line 642) | def __str__(self) -> str:
  class TextStringObject (line 652) | class TextStringObject(str, PdfObject):  # noqa: SLOT000
    method __new__ (line 666) | def __new__(cls, value: Any) -> Self:
    method clone (line 701) | def clone(
    method hash_bin (line 717) | def hash_bin(self) -> int:
    method original_bytes (line 728) | def original_bytes(self) -> bytes:
    method get_original_bytes (line 739) | def get_original_bytes(self) -> bytes:
    method get_encoded_bytes (line 755) | def get_encoded_bytes(self) -> bytes:
    method write_to_stream (line 774) | def write_to_stream(
  class NameObject (line 796) | class NameObject(str, PdfObject):  # noqa: SLOT000
    method clone (line 804) | def clone(
    method hash_bin (line 816) | def hash_bin(self) -> int:
    method write_to_stream (line 826) | def write_to_stream(
    method renumber (line 835) | def renumber(self) -> bytes:
    method _sanitize (line 853) | def _sanitize(self) -> "NameObject":
    method surfix (line 869) | def surfix(cls) -> bytes:  # noqa: N805
    method unnumber (line 874) | def unnumber(sin: bytes) -> bytes:
    method read_from_stream (line 894) | def read_from_stream(stream: StreamType, pdf: Any) -> "NameObject":  #...
  function encode_pdfdocencoding (line 924) | def encode_pdfdocencoding(unicode_string: str) -> bytes:
  function is_null_or_none (line 937) | def is_null_or_none(x: Any) -> TypeGuard[Union[None, NullObject, Indirec...

FILE: pypdf/generic/_data_structures.py
  class ArrayObject (line 99) | class ArrayObject(list[Any], PdfObject):
    method replicate (line 100) | def replicate(
    method clone (line 115) | def clone(
    method hash_bin (line 152) | def hash_bin(self) -> int:
    method items (line 162) | def items(self) -> Iterable[Any]:
    method _to_lst (line 166) | def _to_lst(self, lst: Any) -> list[Any]:
    method __add__ (line 183) | def __add__(self, lst: Any) -> "ArrayObject":
    method __iadd__ (line 202) | def __iadd__(self, lst: Any) -> Self:
    method __isub__ (line 217) | def __isub__(self, lst: Any) -> Self:
    method write_to_stream (line 227) | def write_to_stream(
    method read_from_stream (line 241) | def read_from_stream(
  class DictionaryObject (line 272) | class DictionaryObject(dict[Any, Any], PdfObject):
    method replicate (line 273) | def replicate(
    method clone (line 287) | def clone(
    method _clone (line 311) | def _clone(
    method hash_bin (line 424) | def hash_bin(self) -> int:
    method raw_get (line 436) | def raw_get(self, key: Any) -> Any:
    method get_inherited (line 439) | def get_inherited(self, key: str, default: Any = None) -> Any:
    method __setitem__ (line 464) | def __setitem__(self, key: Any, value: Any) -> Any:
    method setdefault (line 471) | def setdefault(self, key: Any, value: Optional[Any] = None) -> Any:
    method __getitem__ (line 478) | def __getitem__(self, key: Any) -> PdfObject:
    method xmp_metadata (line 482) | def xmp_metadata(self) -> Optional[XmpInformationProtocol]:
    method write_to_stream (line 504) | def write_to_stream(
    method _get_next_object_position (line 522) | def _get_next_object_position(
    method _read_unsized_from_stream (line 534) | def _read_unsized_from_stream(
    method read_from_stream (line 553) | def read_from_stream(
  class TreeObject (line 690) | class TreeObject(DictionaryObject):
    method __init__ (line 691) | def __init__(self, dct: Optional[DictionaryObject] = None) -> None:
    method has_children (line 696) | def has_children(self) -> bool:
    method __iter__ (line 699) | def __iter__(self) -> Any:
    method children (line 702) | def children(self) -> Iterable[Any]:
    method add_child (line 726) | def add_child(self, child: Any, pdf: PdfWriterProtocol) -> None:
    method inc_parent_counter_default (line 729) | def inc_parent_counter_default(
    method inc_parent_counter_outline (line 742) | def inc_parent_counter_outline(
    method insert_child (line 759) | def insert_child(
    method _remove_node_from_tree (line 809) | def _remove_node_from_tree(
    method remove_child (line 852) | def remove_child(self, child: Any) -> None:
    method remove_from_tree (line 889) | def remove_from_tree(self) -> None:
    method empty_tree (line 895) | def empty_tree(self) -> None:
  function _reset_node_tree_relationship (line 908) | def _reset_node_tree_relationship(child_obj: Any) -> None:
  class StreamObject (line 925) | class StreamObject(DictionaryObject):
    method __init__ (line 926) | def __init__(self) -> None:
    method replicate (line 930) | def replicate(
    method _clone (line 955) | def _clone(
    method hash_bin (line 987) | def hash_bin(self) -> int:
    method get_data (line 998) | def get_data(self) -> bytes:
    method set_data (line 1001) | def set_data(self, data: bytes) -> None:
    method hash_value_data (line 1004) | def hash_value_data(self) -> bytes:
    method write_to_stream (line 1009) | def write_to_stream(
    method initialize_from_dictionary (line 1024) | def initialize_from_dictionary(
    method flate_encode (line 1039) | def flate_encode(self, level: int = -1) -> "EncodedStreamObject":
    method decode_as_image (line 1071) | def decode_as_image(self, pillow_parameters: Union[dict[str, Any], Non...
  class DecodedStreamObject (line 1101) | class DecodedStreamObject(StreamObject):
  class EncodedStreamObject (line 1105) | class EncodedStreamObject(StreamObject):
    method __init__ (line 1106) | def __init__(self) -> None:
    method get_data (line 1110) | def get_data(self) -> bytes:
    method set_data (line 1127) | def set_data(self, data: bytes) -> None:
  class ContentStream (line 1147) | class ContentStream(DecodedStreamObject):
    method __init__ (line 1168) | def __init__(
    method replicate (line 1223) | def replicate(
    method clone (line 1253) | def clone(
    method _clone (line 1289) | def _clone(
    method _parse_content_stream (line 1315) | def _parse_content_stream(self, stream: StreamType) -> None:
    method _read_inline_image (line 1346) | def _read_inline_image(self, stream: StreamType) -> dict[str, Any]:
    method get_data (line 1422) | def get_data(self) -> bytes:
    method set_data (line 1444) | def set_data(self, data: bytes) -> None:
    method operations (line 1449) | def operations(self) -> list[tuple[Any, bytes]]:
    method operations (line 1456) | def operations(self, operations: list[tuple[Any, bytes]]) -> None:
    method isolate_graphics_state (line 1460) | def isolate_graphics_state(self) -> None:
    method write_to_stream (line 1468) | def write_to_stream(
  function read_object (line 1476) | def read_object(
  class Field (line 1526) | class Field(TreeObject):
    method __init__ (line 1534) | def __init__(self, data: DictionaryObject) -> None:
    method field_type (line 1558) | def field_type(self) -> Optional[NameObject]:
    method parent (line 1563) | def parent(self) -> Optional[DictionaryObject]:
    method kids (line 1568) | def kids(self) -> Optional["ArrayObject"]:
    method name (line 1573) | def name(self) -> Optional[str]:
    method alternate_name (line 1578) | def alternate_name(self) -> Optional[str]:
    method mapping_name (line 1583) | def mapping_name(self) -> Optional[str]:
    method flags (line 1593) | def flags(self) -> Optional[int]:
    method value (line 1601) | def value(self) -> Optional[Any]:
    method default_value (line 1610) | def default_value(self) -> Optional[Any]:
    method additional_actions (line 1615) | def additional_actions(self) -> Optional[DictionaryObject]:
  class Destination (line 1625) | class Destination(TreeObject):
    method __init__ (line 1646) | def __init__(
    method dest_array (line 1700) | def dest_array(self) -> "ArrayObject":
    method write_to_stream (line 1710) | def write_to_stream(
    method title (line 1734) | def title(self) -> Optional[str]:
    method page (line 1739) | def page(self) -> Optional[IndirectObject]:
    method typ (line 1744) | def typ(self) -> Optional[str]:
    method zoom (line 1749) | def zoom(self) -> Optional[int]:
    method left (line 1754) | def left(self) -> Optional[FloatObject]:
    method right (line 1759) | def right(self) -> Optional[FloatObject]:
    method top (line 1764) | def top(self) -> Optional[FloatObject]:
    method bottom (line 1769) | def bottom(self) -> Optional[FloatObject]:
    method color (line 1774) | def color(self) -> Optional["ArrayObject"]:
    method font_format (line 1781) | def font_format(self) -> Optional[OutlineFontFlag]:
    method outline_count (line 1790) | def outline_count(self) -> Optional[int]:

FILE: pypdf/generic/_files.py
  class EmbeddedFile (line 32) | class EmbeddedFile:
    method __init__ (line 40) | def __init__(self, name: str, pdf_object: DictionaryObject, parent: Ar...
    method name (line 52) | def name(self) -> str:
    method _create_new (line 57) | def _create_new(cls, writer: PdfWriter, name: str, content: str | byte...
    method _get_names_array (line 107) | def _get_names_array(cls, writer: PdfWriter) -> ArrayObject:
    method _get_insertion_index (line 151) | def _get_insertion_index(cls, names_array: ArrayObject, name: str) -> ...
    method alternative_name (line 167) | def alternative_name(self) -> str | None:
    method alternative_name (line 179) | def alternative_name(self, value: TextStringObject | None) -> None:
    method description (line 191) | def description(self) -> str | None:
    method description (line 199) | def description(self, value: TextStringObject | None) -> None:
    method associated_file_relationship (line 207) | def associated_file_relationship(self) -> str:
    method associated_file_relationship (line 212) | def associated_file_relationship(self, value: NameObject) -> None:
    method _embedded_file (line 217) | def _embedded_file(self) -> StreamObject:
    method _params (line 228) | def _params(self) -> DictionaryObject:
    method _ensure_params (line 233) | def _ensure_params(self) -> DictionaryObject:
    method subtype (line 241) | def subtype(self) -> str | None:
    method subtype (line 249) | def subtype(self, value: NameObject | None) -> None:
    method content (line 258) | def content(self) -> bytes:
    method content (line 263) | def content(self, value: str | bytes) -> None:
    method size (line 270) | def size(self) -> int | None:
    method size (line 278) | def size(self, value: NumberObject | None) -> None:
    method creation_date (line 287) | def creation_date(self) -> datetime.datetime | None:
    method creation_date (line 292) | def creation_date(self, value: datetime.datetime | None) -> None:
    method modification_date (line 302) | def modification_date(self) -> datetime.datetime | None:
    method modification_date (line 307) | def modification_date(self, value: datetime.datetime | None) -> None:
    method checksum (line 317) | def checksum(self) -> bytes | None:
    method checksum (line 325) | def checksum(self, value: ByteStringObject | None) -> None:
    method delete (line 333) | def delete(self) -> None:
    method __repr__ (line 350) | def __repr__(self) -> str:
    method _load_from_names (line 354) | def _load_from_names(cls, names: ArrayObject) -> Generator[EmbeddedFile]:
    method _load (line 373) | def _load(cls, catalog: DictionaryObject) -> Generator[EmbeddedFile]:

FILE: pypdf/generic/_fit.py
  class Fit (line 6) | class Fit:
    method __init__ (line 7) | def __init__(
    method xyz (line 18) | def xyz(
    method fit (line 46) | def fit(cls) -> "Fit":
    method fit_horizontally (line 59) | def fit_horizontally(cls, top: Optional[float] = None) -> "Fit":
    method fit_vertically (line 79) | def fit_vertically(cls, left: Optional[float] = None) -> "Fit":
    method fit_rectangle (line 83) | def fit_rectangle(
    method fit_box (line 116) | def fit_box(cls) -> "Fit":
    method fit_box_horizontally (line 129) | def fit_box_horizontally(cls, top: Optional[float] = None) -> "Fit":
    method fit_box_vertically (line 149) | def fit_box_vertically(cls, left: Optional[float] = None) -> "Fit":
    method __str__ (line 168) | def __str__(self) -> str:

FILE: pypdf/generic/_image_inline.py
  function _check_end_image_marker (line 48) | def _check_end_image_marker(stream: StreamType) -> bool:
  function extract_inline__ascii_hex_decode (line 55) | def extract_inline__ascii_hex_decode(stream: StreamType) -> bytes:
  function extract_inline__ascii85_decode (line 93) | def extract_inline__ascii85_decode(stream: StreamType) -> bytes:
  function extract_inline__run_length_decode (line 122) | def extract_inline__run_length_decode(stream: StreamType) -> bytes:
  function extract_inline__dct_decode (line 161) | def extract_inline__dct_decode(stream: StreamType) -> bytes:
  function extract_inline_default (line 208) | def extract_inline_default(stream: StreamType) -> bytes:
  function is_followed_by_binary_data (line 260) | def is_followed_by_binary_data(stream: IO[bytes], length: int = 10) -> b...

FILE: pypdf/generic/_image_xobject.py
  function _get_image_mode (line 42) | def _get_image_mode(
  function bits2byte (line 124) | def bits2byte(data: bytes, size: tuple[int, int], bits: int) -> bytes:
  function _extended_image_from_bytes (line 142) | def _extended_image_from_bytes(
  function __handle_flate__indexed (line 162) | def __handle_flate__indexed(color_space: ArrayObject) -> tuple[Any, Any,...
  function _handle_flate (line 180) | def _handle_flate(
  function _handle_jpx (line 295) | def _handle_jpx(
  function _apply_decode (line 332) | def _apply_decode(
  function _get_mode_and_invert_color (line 375) | def _get_mode_and_invert_color(
  function _xobj_to_image (line 405) | def _xobj_to_image(

FILE: pypdf/generic/_link.py
  class NamedReferenceLink (line 42) | class NamedReferenceLink:
    method __init__ (line 45) | def __init__(self, reference: TextStringObject, source_pdf: "PdfReader...
    method find_referenced_page (line 50) | def find_referenced_page(self) -> Union[IndirectObject, None]:
    method patch_reference (line 54) | def patch_reference(self, target_pdf: "PdfWriter", new_page: IndirectO...
  class DirectReferenceLink (line 61) | class DirectReferenceLink:
    method __init__ (line 64) | def __init__(self, reference: ArrayObject) -> None:
    method find_referenced_page (line 68) | def find_referenced_page(self) -> IndirectObject:
    method patch_reference (line 71) | def patch_reference(self, target_pdf: "PdfWriter", new_page: IndirectO...
  function extract_links (line 79) | def extract_links(new_page: "PageObject", old_page: "PageObject") -> lis...
  function _build_link (line 109) | def _build_link(indirect_object: IndirectObject, page: "PageObject") -> ...
  function _create_link (line 130) | def _create_link(reference: PdfObject, source_pdf: "PdfReader") -> Optio...

FILE: pypdf/generic/_outline.py
  class OutlineItem (line 8) | class OutlineItem(Destination):
    method write_to_stream (line 9) | def write_to_stream(

FILE: pypdf/generic/_rectangle.py
  class RectangleObject (line 7) | class RectangleObject(ArrayObject):
    method __init__ (line 20) | def __init__(
    method _ensure_is_number (line 28) | def _ensure_is_number(self, value: Any) -> Union[FloatObject, NumberOb...
    method scale (line 33) | def scale(self, sx: float, sy: float) -> "RectangleObject":
    method __repr__ (line 43) | def __repr__(self) -> str:
    method left (line 47) | def left(self) -> FloatObject:
    method left (line 51) | def left(self, f: float) -> None:
    method bottom (line 55) | def bottom(self) -> FloatObject:
    method bottom (line 59) | def bottom(self, f: float) -> None:
    method right (line 63) | def right(self) -> FloatObject:
    method right (line 67) | def right(self, f: float) -> None:
    method top (line 71) | def top(self) -> FloatObject:
    method top (line 75) | def top(self, f: float) -> None:
    method lower_left (line 79) | def lower_left(self) -> tuple[float, float]:
    method lower_left (line 87) | def lower_left(self, value: tuple[float, float]) -> None:
    method lower_right (line 91) | def lower_right(self) -> tuple[float, float]:
    method lower_right (line 99) | def lower_right(self, value: tuple[float, float]) -> None:
    method upper_left (line 103) | def upper_left(self) -> tuple[float, float]:
    method upper_left (line 111) | def upper_left(self, value: tuple[float, float]) -> None:
    method upper_right (line 115) | def upper_right(self) -> tuple[float, float]:
    method upper_right (line 123) | def upper_right(self, value: tuple[float, float]) -> None:
    method width (line 127) | def width(self) -> float:
    method height (line 131) | def height(self) -> float:

FILE: pypdf/generic/_utils.py
  function hex_to_rgb (line 10) | def hex_to_rgb(value: str) -> tuple[float, float, float]:
  function read_hex_string_from_stream (line 14) | def read_hex_string_from_stream(
  function read_string_from_stream (line 62) | def read_string_from_stream(
  function create_string_object (line 123) | def create_string_object(
  function decode_pdfdocencoding (line 195) | def decode_pdfdocencoding(byte_array: bytes) -> str:

FILE: pypdf/generic/_viewerpref.py
  class ViewerPreferences (line 40) | class ViewerPreferences(DictionaryObject):
    method __init__ (line 41) | def __init__(self, obj: Optional[DictionaryObject] = None) -> None:
    method _get_bool (line 50) | def _get_bool(self, key: str, default: Optional[BooleanObject]) -> Opt...
    method _set_bool (line 53) | def _set_bool(self, key: str, v: bool) -> None:
    method _get_name (line 56) | def _get_name(self, key: str, default: Optional[NameObject]) -> Option...
    method _set_name (line 59) | def _set_name(self, key: str, lst: list[str], v: NameObject) -> None:
    method _get_arr (line 66) | def _get_arr(self, key: str, default: Optional[list[Any]]) -> Optional...
    method _set_arr (line 69) | def _set_arr(self, key: str, v: Optional[ArrayObject]) -> None:
    method _get_int (line 80) | def _get_int(self, key: str, default: Optional[NumberObject]) -> Optio...
    method _set_int (line 83) | def _set_int(self, key: str, v: int) -> None:
    method PRINT_SCALING (line 87) | def PRINT_SCALING(self) -> NameObject:
    method __new__ (line 90) | def __new__(cls: Any, value: Any = None) -> "ViewerPreferences":  # no...

FILE: pypdf/pagerange.py
  class PageRange (line 19) | class PageRange:
    method __init__ (line 36) | def __init__(self, arg: Union[slice, "PageRange", str]) -> None:
    method valid (line 80) | def valid(input: Any) -> bool:
    method to_slice (line 95) | def to_slice(self) -> slice:
    method __str__ (line 99) | def __str__(self) -> str:
    method __repr__ (line 112) | def __repr__(self) -> str:
    method indices (line 116) | def indices(self, n: int) -> tuple[int, int, int]:
    method __eq__ (line 132) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 137) | def __hash__(self) -> int:
    method __add__ (line 140) | def __add__(self, other: "PageRange") -> "PageRange":
  function parse_filename_page_ranges (line 161) | def parse_filename_page_ranges(

FILE: pypdf/papersizes.py
  class Dimensions (line 6) | class Dimensions(NamedTuple):
  class PaperSize (line 11) | class PaperSize:

FILE: pypdf/xmp.py
  function _identity (line 105) | def _identity(value: K) -> K:
  function _converter_date (line 109) | def _converter_date(value: str) -> datetime.datetime:
  function _format_datetime_utc (line 136) | def _format_datetime_utc(value: datetime.datetime) -> str:
  function _generic_get (line 149) | def _generic_get(
  class XmpInformation (line 164) | class XmpInformation(XmpInformationProtocol, PdfObject):
    method __init__ (line 174) | def __init__(self, stream: ContentStream) -> None:
    method create (line 187) | def create(cls) -> "XmpInformation":
    method write_to_stream (line 198) | def write_to_stream(
    method get_element (line 212) | def get_element(self, about_uri: str, namespace: str, name: str) -> It...
    method get_nodes_in_namespace (line 220) | def get_nodes_in_namespace(self, about_uri: str, namespace: str) -> It...
    method _get_text (line 231) | def _get_text(self, element: XmlElement) -> str:
    method _get_single_value (line 238) | def _get_single_value(
    method _getter_bag (line 260) | def _getter_bag(self, namespace: str, name: str) -> Optional[list[str]]:
    method _get_seq_values (line 275) | def _get_seq_values(
    method _get_langalt_values (line 304) | def _get_langalt_values(self, namespace: str, name: str) -> Optional[d...
    method dc_contributor (line 323) | def dc_contributor(self) -> Optional[list[str]]:
    method dc_contributor (line 328) | def dc_contributor(self, values: Optional[list[str]]) -> None:
    method dc_coverage (line 332) | def dc_coverage(self) -> Optional[str]:
    method dc_coverage (line 337) | def dc_coverage(self, value: Optional[str]) -> None:
    method dc_creator (line 341) | def dc_creator(self) -> Optional[list[str]]:
    method dc_creator (line 346) | def dc_creator(self, values: Optional[list[str]]) -> None:
    method dc_date (line 350) | def dc_date(self) -> Optional[list[datetime.datetime]]:
    method dc_date (line 355) | def dc_date(self, values: Optional[list[Union[str, datetime.datetime]]...
    method dc_description (line 368) | def dc_description(self) -> Optional[dict[str, str]]:
    method dc_description (line 373) | def dc_description(self, values: Optional[dict[str, str]]) -> None:
    method dc_format (line 377) | def dc_format(self) -> Optional[str]:
    method dc_format (line 382) | def dc_format(self, value: Optional[str]) -> None:
    method dc_identifier (line 386) | def dc_identifier(self) -> Optional[str]:
    method dc_identifier (line 391) | def dc_identifier(self, value: Optional[str]) -> None:
    method dc_language (line 395) | def dc_language(self) -> Optional[list[str]]:
    method dc_language (line 400) | def dc_language(self, values: Optional[list[str]]) -> None:
    method dc_publisher (line 404) | def dc_publisher(self) -> Optional[list[str]]:
    method dc_publisher (line 409) | def dc_publisher(self, values: Optional[list[str]]) -> None:
    method dc_relation (line 413) | def dc_relation(self) -> Optional[list[str]]:
    method dc_relation (line 418) | def dc_relation(self, values: Optional[list[str]]) -> None:
    method dc_rights (line 422) | def dc_rights(self) -> Optional[dict[str, str]]:
    method dc_rights (line 427) | def dc_rights(self, values: Optional[dict[str, str]]) -> None:
    method dc_source (line 431) | def dc_source(self) -> Optional[str]:
    method dc_source (line 436) | def dc_source(self, value: Optional[str]) -> None:
    method dc_subject (line 440) | def dc_subject(self) -> Optional[list[str]]:
    method dc_subject (line 445) | def dc_subject(self, values: Optional[list[str]]) -> None:
    method dc_title (line 449) | def dc_title(self) -> Optional[dict[str, str]]:
    method dc_title (line 454) | def dc_title(self, values: Optional[dict[str, str]]) -> None:
    method dc_type (line 458) | def dc_type(self) -> Optional[list[str]]:
    method dc_type (line 463) | def dc_type(self, values: Optional[list[str]]) -> None:
    method pdf_keywords (line 467) | def pdf_keywords(self) -> Optional[str]:
    method pdf_keywords (line 472) | def pdf_keywords(self, value: Optional[str]) -> None:
    method pdf_pdfversion (line 476) | def pdf_pdfversion(self) -> Optional[str]:
    method pdf_pdfversion (line 481) | def pdf_pdfversion(self, value: Optional[str]) -> None:
    method pdf_producer (line 485) | def pdf_producer(self) -> Optional[str]:
    method pdf_producer (line 490) | def pdf_producer(self, value: Optional[str]) -> None:
    method xmp_create_date (line 494) | def xmp_create_date(self) -> Optional[datetime.datetime]:
    method xmp_create_date (line 499) | def xmp_create_date(self, value: Optional[datetime.datetime]) -> None:
    method xmp_modify_date (line 507) | def xmp_modify_date(self) -> Optional[datetime.datetime]:
    method xmp_modify_date (line 512) | def xmp_modify_date(self, value: Optional[datetime.datetime]) -> None:
    method xmp_metadata_date (line 520) | def xmp_metadata_date(self) -> Optional[datetime.datetime]:
    method xmp_metadata_date (line 525) | def xmp_metadata_date(self, value: Optional[datetime.datetime]) -> None:
    method xmp_creator_tool (line 533) | def xmp_creator_tool(self) -> Optional[str]:
    method xmp_creator_tool (line 538) | def xmp_creator_tool(self, value: Optional[str]) -> None:
    method xmpmm_document_id (line 542) | def xmpmm_document_id(self) -> Optional[str]:
    method xmpmm_document_id (line 547) | def xmpmm_document_id(self, value: Optional[str]) -> None:
    method xmpmm_instance_id (line 551) | def xmpmm_instance_id(self) -> Optional[str]:
    method xmpmm_instance_id (line 556) | def xmpmm_instance_id(self, value: Optional[str]) -> None:
    method pdfaid_part (line 560) | def pdfaid_part(self) -> Optional[str]:
    method pdfaid_part (line 565) | def pdfaid_part(self, value: Optional[str]) -> None:
    method pdfaid_conformance (line 569) | def pdfaid_conformance(self) -> Optional[str]:
    method pdfaid_conformance (line 574) | def pdfaid_conformance(self, value: Optional[str]) -> None:
    method custom_properties (line 578) | def custom_properties(self) -> dict[Any, Any]:
    method _get_or_create_description (line 608) | def _get_or_create_description(self, about_uri: str = "") -> XmlElement:
    method _clear_cache_entry (line 622) | def _clear_cache_entry(self, namespace: str, name: str) -> None:
    method _set_single_value (line 628) | def _set_single_value(self, namespace: str, name: str, value: Optional...
    method _set_bag_values (line 652) | def _set_bag_values(self, namespace: str, name: str, values: Optional[...
    method _set_seq_values (line 680) | def _set_seq_values(self, namespace: str, name: str, values: Optional[...
    method _set_langalt_values (line 708) | def _set_langalt_values(self, namespace: str, name: str, values: Optio...
    method _get_namespace_prefix (line 737) | def _get_namespace_prefix(self, namespace: str) -> str:
    method _update_stream (line 741) | def _update_stream(self) -> None:

FILE: resources/afm_to_dataclass.py
  class Parser (line 18) | class Parser:
    method __init__ (line 19) | def __init__(self) -> None:
    method get_fonts (line 23) | def get_fonts(self) -> None:
    method get_disclaimer (line 37) | def get_disclaimer(self, width: int = 95) -> str:
    method _handle_font (line 50) | def _handle_font(self, file_name: str, font_data: str) -> list[str]:  ...
    method get_font_data (line 170) | def get_font_data(self) -> str:

FILE: tests/__init__.py
  function _get_data_from_url (line 23) | def _get_data_from_url(url: str) -> bytes:
  function get_data_from_url (line 41) | def get_data_from_url(url: Optional[str] = None, name: Optional[str] = N...
  function _strip_position (line 77) | def _strip_position(line: str) -> str:
  function normalize_warnings (line 98) | def normalize_warnings(caplog_text: str) -> list[str]:
  function is_sublist (line 102) | def is_sublist(child_list, parent_list):
  function read_yaml_to_list_of_dicts (line 119) | def read_yaml_to_list_of_dicts(yaml_file: Path) -> list[dict[str, str]]:
  function download_test_pdfs (line 124) | def download_test_pdfs():
  class PILContext (line 140) | class PILContext:
    method __init__ (line 143) | def __init__(self) -> None:
    method __enter__ (line 146) | def __enter__(self) -> Self:
    method __exit__ (line 153) | def __exit__(self, type_, value, traceback) -> Optional[bool]:

FILE: tests/bench.py
  function page_ops (line 19) | def page_ops(pdf_path, password):
  function test_page_operations (line 53) | def test_page_operations(benchmark):
  function merge (line 62) | def merge():
  function test_merge (line 119) | def test_merge(benchmark):
  function text_extraction (line 128) | def text_extraction(pdf_path):
  function test_text_extraction (line 137) | def test_text_extraction(benchmark):
  function read_string_from_stream_performance (line 142) | def read_string_from_stream_performance():
  function test_read_string_from_stream_performance (line 147) | def test_read_string_from_stream_performance(benchmark):
  function image_new_property (line 157) | def image_new_property(data):
  function test_image_new_property_performance (line 217) | def test_image_new_property_performance(benchmark):
  function image_extraction (line 225) | def image_extraction(data):
  function test_large_compressed_image_performance (line 231) | def test_large_compressed_image_performance(benchmark):

FILE: tests/conftest.py
  function pdf_file_path (line 9) | def pdf_file_path(tmp_path_factory):
  function txt_file_path (line 14) | def txt_file_path(tmp_path_factory):

FILE: tests/generic/test_base.py
  function test_text_string_object__looks_like_bom (line 18) | def test_text_string_object__looks_like_bom(source: bytes, expected: str...
  function test_text_string_object__wrongly_detected_bom (line 25) | def test_text_string_object__wrongly_detected_bom():

FILE: tests/generic/test_data_structures.py
  function test_dictionary_object__get_next_object_position (line 31) | def test_dictionary_object__get_next_object_position():
  function test_tree_object__cyclic_reference (line 52) | def test_tree_object__cyclic_reference(caplog):
  function test_array_object__clone_same_object_multiple_times (line 67) | def test_array_object__clone_same_object_multiple_times(caplog):
  function test_array_object__clone_same_stream_multiple_times (line 79) | def test_array_object__clone_same_stream_multiple_times():
  function test_dictionary_object__read_from_stream__limit (line 124) | def test_dictionary_object__read_from_stream__limit():
  function _prepare_test_dictionary_object__read_from_stream__no_limit (line 138) | def _prepare_test_dictionary_object__read_from_stream__no_limit(
  function test_dictionary_object__read_from_stream__no_limit (line 167) | def test_dictionary_object__read_from_stream__no_limit(tmp_path):
  function test_dictionary_object__read_from_stream__no_limit__path (line 199) | def test_dictionary_object__read_from_stream__no_limit__path(tmp_path):
  function _get_array_based_buffer (line 227) | def _get_array_based_buffer(stream_count: int, chunk_bytes: int) -> Byte...
  function test_content_stream__array_based__performance (line 244) | def test_content_stream__array_based__performance():
  function test_content_stream__array_based__length (line 250) | def test_content_stream__array_based__length():
  function test_content_stream__array_based__output_length (line 260) | def test_content_stream__array_based__output_length():

FILE: tests/generic/test_files.py
  function test_embedded_file__basic (line 30) | def test_embedded_file__basic(tmpdir):
  function test_embedded_file__artificial (line 52) | def test_embedded_file__artificial():
  function test_embedded_file__kids (line 83) | def test_embedded_file__kids():
  function test_embedded_file__ensure_params__existing_params (line 122) | def test_embedded_file__ensure_params__existing_params():
  function test_embedded_file__name_is_read_only (line 148) | def test_embedded_file__name_is_read_only():
  function test_embedded_file__alternative_name_setter (line 158) | def test_embedded_file__alternative_name_setter():
  function test_embedded_file__alternative_name__uf_key_only (line 177) | def test_embedded_file__alternative_name__uf_key_only():
  function test_embedded_file__alternative_name__f_key_only (line 196) | def test_embedded_file__alternative_name__f_key_only():
  function test_embedded_file__alternative_name__both_f_and_uf (line 216) | def test_embedded_file__alternative_name__both_f_and_uf():
  function test_embedded_file__description_setter (line 234) | def test_embedded_file__description_setter():
  function test_embedded_file__subtype_setter (line 249) | def test_embedded_file__subtype_setter():
  function test_embedded_file__content_setter (line 264) | def test_embedded_file__content_setter():
  function test_embedded_file__size_setter (line 276) | def test_embedded_file__size_setter():
  function test_embedded_file__size_getter (line 291) | def test_embedded_file__size_getter():
  function test_embedded_file__creation_date_setter (line 303) | def test_embedded_file__creation_date_setter():
  function test_embedded_file__modification_date_setter (line 315) | def test_embedded_file__modification_date_setter():
  function test_embedded_file__checksum_setter (line 327) | def test_embedded_file__checksum_setter():
  function test_embedded_file__associated_file_relationship_setter (line 343) | def test_embedded_file__associated_file_relationship_setter():
  function test_embedded_file__setters_integration (line 351) | def test_embedded_file__setters_integration():
  function test_embedded_file__null_object_handling (line 377) | def test_embedded_file__null_object_handling():
  function test_embedded_file__delete_without_parent (line 400) | def test_embedded_file__delete_without_parent():
  function test_embedded_file__delete_known (line 406) | def test_embedded_file__delete_known():
  function test_embedded_file__delete__no_indirect_reference (line 427) | def test_embedded_file__delete__no_indirect_reference():
  function test_embedded_file__create__kids_based_name_tree (line 444) | def test_embedded_file__create__kids_based_name_tree():
  function test_embedded_file__create__neither_kids_nor_names (line 479) | def test_embedded_file__create__neither_kids_nor_names():
  function test_embedded_file__get_insertion_index (line 491) | def test_embedded_file__get_insertion_index():
  function test_embedded_file__order (line 552) | def test_embedded_file__order():

FILE: tests/generic/test_image_inline.py
  function test_is_followed_by_binary_data (line 12) | def test_is_followed_by_binary_data():
  function test_extract_inline_dct__early_end_of_file (line 70) | def test_extract_inline_dct__early_end_of_file():
  function test_extract_inline_dct__multiple_eod (line 81) | def test_extract_inline_dct__multiple_eod():

FILE: tests/generic/test_image_xobject.py
  function test_get_imagemode_recursion_depth (line 19) | def test_get_imagemode_recursion_depth():
  function test_handle_flate__image_mode_1 (line 36) | def test_handle_flate__image_mode_1(caplog):
  function test_extended_image_frombytes_zero_data (line 126) | def test_extended_image_frombytes_zero_data():
  function test_handle_flate__autodesk_indexed (line 135) | def test_handle_flate__autodesk_indexed():
  function test_get_mode_and_invert_color (line 155) | def test_get_mode_and_invert_color():
  function test_get_imagemode__empty_array (line 165) | def test_get_imagemode__empty_array():
  function test_p_image_with_alpha_mask (line 175) | def test_p_image_with_alpha_mask():
  function test_handle_flate__icc_based__image_mode_1 (line 216) | def test_handle_flate__icc_based__image_mode_1():
  function test_handle_jpx__explicit_decode (line 241) | def test_handle_jpx__explicit_decode():

FILE: tests/generic/test_link.py
  function test_extract_links__null_object_in_old_page (line 12) | def test_extract_links__null_object_in_old_page():
  function test_extract_links (line 21) | def test_extract_links(caplog):

FILE: tests/scripts/test_example_files.py
  function test_consistency (line 8) | def test_consistency():

FILE: tests/scripts/test_make_release.py
  function test_strip_header (line 35) | def test_strip_header(data, expected):
  function test_get_git_commits_since_tag (line 41) | def test_get_git_commits_since_tag():
  function test_get_formatted_changes (line 87) | def test_get_formatted_changes():
  function test_get_formatted_changes__other (line 131) | def test_get_formatted_changes__other():

FILE: tests/test_annotations.py
  function test_ellipse (line 28) | def test_ellipse(pdf_file_path):
  function test_text (line 48) | def test_text(pdf_file_path):
  function test_free_text (line 69) | def test_free_text(pdf_file_path):
  function test_free_text__font_specifier (line 109) | def test_free_text__font_specifier():
  function test_annotation_dictionary (line 129) | def test_annotation_dictionary():
  function test_polygon (line 135) | def test_polygon(pdf_file_path):
  function test_polyline (line 158) | def test_polyline(pdf_file_path):
  function test_line (line 184) | def test_line(pdf_file_path):
  function test_rectangle (line 206) | def test_rectangle(pdf_file_path):
  function test_highlight (line 228) | def test_highlight(pdf_file_path):
  function test_link (line 292) | def test_link(pdf_file_path):
  function test_popup (line 339) | def test_popup(caplog):
  function test_markup_annotation_in_reply_to (line 374) | def test_markup_annotation_in_reply_to():
  function test_markup_annotation_in_reply_to_group_type (line 411) | def test_markup_annotation_in_reply_to_group_type():
  function test_markup_annotation_name_without_reply (line 434) | def test_markup_annotation_name_without_reply():
  function test_markup_annotation_reply_type_without_reply (line 444) | def test_markup_annotation_reply_type_without_reply():
  function test_markup_annotation_in_reply_to_custom_name (line 454) | def test_markup_annotation_in_reply_to_custom_name():
  function test_markup_annotation_in_reply_to_unregistered (line 474) | def test_markup_annotation_in_reply_to_unregistered():
  function test_markup_annotation_in_reply_to_indirect_object (line 485) | def test_markup_annotation_in_reply_to_indirect_object():
  function test_outline_action_without_d_lenient (line 517) | def test_outline_action_without_d_lenient():
  function test_outline_action_without_d_strict (line 523) | def test_outline_action_without_d_strict(pdf_file_path):

FILE: tests/test_appearance_stream.py
  function test_comb (line 6) | def test_comb():
  function test_scale_text (line 38) | def test_scale_text():

FILE: tests/test_cmap.py
  function test_text_extraction_slow (line 46) | def test_text_extraction_slow(caplog, url: str, name: str, strict: bool):
  function test_text_extraction_fast (line 82) | def test_text_extraction_fast(caplog, url: str, name: str, strict: bool):
  function test_parse_encoding_advanced_encoding_not_implemented (line 91) | def test_parse_encoding_advanced_encoding_not_implemented(caplog):
  function test_ascii_charset (line 100) | def test_ascii_charset():
  function test_text_extraction_of_specific_pages (line 125) | def test_text_extraction_of_specific_pages(
  function test_iss1533 (line 133) | def test_iss1533():
  function test_cmap_encodings (line 160) | def test_cmap_encodings(caplog, url, name, page_index, within_text, capl...
  function test_latex (line 169) | def test_latex():
  function test_unixxx_glyphs (line 178) | def test_unixxx_glyphs():
  function test_cmap_compute_space_width (line 186) | def test_cmap_compute_space_width():
  function test_tabs_in_cmap (line 197) | def test_tabs_in_cmap():
  function test_ignoring_non_put_entries (line 204) | def test_ignoring_non_put_entries():
  function test_eten_b5 (line 211) | def test_eten_b5():
  function test_missing_entries_in_cmap (line 217) | def test_missing_entries_in_cmap():
  function test_null_missing_width (line 232) | def test_null_missing_width():
  function test_unigb_utf16 (line 243) | def test_unigb_utf16():
  function test_too_many_differences (line 254) | def test_too_many_differences():
  function test_iss2925 (line 265) | def test_iss2925():
  function test_iss2966 (line 275) | def test_iss2966():
  function test_binascii_odd_length_string (line 286) | def test_binascii_odd_length_string(caplog):
  function test_standard_encoding (line 298) | def test_standard_encoding(caplog):
  function test_function_in_font_widths (line 310) | def test_function_in_font_widths(caplog):
  function test_get_encoding__encoding_value_is_none (line 321) | def test_get_encoding__encoding_value_is_none():
  function test_parse_bfchar (line 330) | def test_parse_bfchar(caplog):
  function test_parse_bfrange__iteration_limit (line 341) | def test_parse_bfrange__iteration_limit():
  function test_parse_bfchar__iteration_limit (line 414) | def test_parse_bfchar__iteration_limit():

FILE: tests/test_codecs.py
  function test_encode_decode (line 28) | def test_encode_decode(data):
  function test_encode_lzw (line 45) | def test_encode_lzw(plain, expected_encoded):
  function test_decode_lzw (line 60) | def test_decode_lzw(encoded, expected_decoded):
  function test_lzw_decoder_table_overflow (line 66) | def test_lzw_decoder_table_overflow(caplog):
  function test_lzw_decoder_large_stream_performance (line 78) | def test_lzw_decoder_large_stream_performance(caplog):
  function test_lzw_decoder__output_limit (line 83) | def test_lzw_decoder__output_limit():

FILE: tests/test_constants.py
  function test_slash_prefix (line 10) | def test_slash_prefix():
  function test_user_access_permissions__dict_handling (line 42) | def test_user_access_permissions__dict_handling():
  function test_user_access_permissions__all (line 105) | def test_user_access_permissions__all():

FILE: tests/test_doc_common.py
  function test_attachments (line 32) | def test_attachments(tmpdir):
  function test_get_attachments__same_attachment_more_than_twice (line 90) | def test_get_attachments__same_attachment_more_than_twice():
  function test_get_attachments__alternative_name_is_none (line 107) | def test_get_attachments__alternative_name_is_none():
  function test_byte_encoded_named_destinations (line 122) | def test_byte_encoded_named_destinations():
  function test_viewer_preferences__indirect_reference (line 181) | def test_viewer_preferences__indirect_reference():
  function test_named_destinations__tree_is_null_object (line 194) | def test_named_destinations__tree_is_null_object():
  function test_outline__issue3462 (line 203) | def test_outline__issue3462():
  function test_flatten__cyclic_references (line 462) | def test_flatten__cyclic_references():
  function test_get_outline__cyclic_references (line 480) | def test_get_outline__cyclic_references(caplog):
  function test_get_outline__cyclic_references__nested_handling (line 504) | def test_get_outline__cyclic_references__nested_handling(caplog):
  function test_xfa__decompression_limit (line 559) | def test_xfa__decompression_limit():

FILE: tests/test_encryption.py
  function test_encryption (line 69) | def test_encryption(name, requires_aes):
  function test_pdf_with_both_passwords (line 116) | def test_pdf_with_both_passwords(name, user_passwd, owner_passwd):
  function test_aesv2_without_length_in_encrypt_dict (line 135) | def test_aesv2_without_length_in_encrypt_dict():
  function test_read_page_from_encrypted_file_aes_256 (line 159) | def test_read_page_from_encrypted_file_aes_256(pdffile, password):
  function test_merge_encrypted_pdfs (line 185) | def test_merge_encrypted_pdfs(names):
  function test_encrypt_decrypt_with_cipher_class (line 208) | def test_encrypt_decrypt_with_cipher_class(cryptcls):
  function test_attempt_decrypt_unencrypted_pdf (line 216) | def test_attempt_decrypt_unencrypted_pdf():
  function test_alg_v5_generate_values (line 225) | def test_alg_v5_generate_values():
  function test_pdf_encrypt (line 261) | def test_pdf_encrypt(pdf_file_path, alg, requires_aes):
  function test_pdf_encrypt_multiple (line 315) | def test_pdf_encrypt_multiple(pdf_file_path, count):
  function test_aes_decrypt_corrupted_data (line 353) | def test_aes_decrypt_corrupted_data():
  function test_encrypt_stream_dictionary (line 361) | def test_encrypt_stream_dictionary(pdf_file_path):
  function test_are_permissions_valid_none_for_unencrypted (line 387) | def test_are_permissions_valid_none_for_unencrypted():
  function test_are_permissions_valid_none_before_decrypt (line 394) | def test_are_permissions_valid_none_before_decrypt():
  function test_are_permissions_valid_true_for_valid_r6 (line 401) | def test_are_permissions_valid_true_for_valid_r6():
  function test_are_permissions_valid_true_for_v4 (line 408) | def test_are_permissions_valid_true_for_v4():
  function test_are_permissions_valid_false_when_tampered (line 420) | def test_are_permissions_valid_false_when_tampered():

FILE: tests/test_filters.py
  function test_flate_decode_encode (line 64) | def test_flate_decode_encode(predictor, s):
  function test_flatedecode_unsupported_predictor (line 72) | def test_flatedecode_unsupported_predictor():
  function test_ascii_hex_decode_method (line 127) | def test_ascii_hex_decode_method(data, expected):
  function test_ascii_hex_decode_missing_eod (line 135) | def test_ascii_hex_decode_missing_eod(caplog):
  function test_decode_ahx (line 142) | def test_decode_ahx():
  function test_ascii85decode_with_overflow (line 152) | def test_ascii85decode_with_overflow():
  function test_ascii85decode_five_zero_bytes (line 169) | def test_ascii85decode_five_zero_bytes():
  function test_ccitparameters (line 192) | def test_ccitparameters():
  function test_ccittparameters (line 200) | def test_ccittparameters():
  function test_ccitt_get_parameters (line 217) | def test_ccitt_get_parameters(parameters, expected_k, expected_black_is_1):
  function test_ccitt_get_parameters__indirect_object (line 223) | def test_ccitt_get_parameters__indirect_object():
  function test_ccitt_fax_decode (line 234) | def test_ccitt_fax_decode():
  function test_decompress_zlib_error (line 253) | def test_decompress_zlib_error(caplog):
  function test_lzw_decode_neg1 (line 261) | def test_lzw_decode_neg1():
  function test_issue_399 (line 268) | def test_issue_399():
  function test_image_without_pillow (line 274) | def test_image_without_pillow(tmp_path):
  function test_issue_1737 (line 322) | def test_issue_1737():
  function test_pa_image_extraction (line 330) | def test_pa_image_extraction():
  function test_1bit_image_extraction (line 349) | def test_1bit_image_extraction():
  function test_png_transparency_reverse (line 357) | def test_png_transparency_reverse():
  function test_iss1787 (line 371) | def test_iss1787():
  function test_tiff_predictor (line 387) | def test_tiff_predictor():
  function test_rgba (line 398) | def test_rgba():
  function test_cmyk (line 412) | def test_cmyk():
  function test_iss1863 (line 431) | def test_iss1863():
  function test_read_images (line 440) | def test_read_images():
  function test_cascaded_filters_images (line 448) | def test_cascaded_filters_images():
  function test_calrgb (line 457) | def test_calrgb():
  function test_index_lookup (line 463) | def test_index_lookup():
  function test_2bits_image (line 486) | def test_2bits_image():
  function test_gray_devicen_cmyk (line 497) | def test_gray_devicen_cmyk():
  function test_runlengthdecode (line 514) | def test_runlengthdecode():
  function test_gray_separation_cmyk (line 534) | def test_gray_separation_cmyk():
  function test_singleton_device (line 551) | def test_singleton_device():
  function test_jpx_no_spacecode (line 560) | def test_jpx_no_spacecode():
  function test_encodedstream_lookup (line 575) | def test_encodedstream_lookup():
  function test_convert_1_to_la (line 584) | def test_convert_1_to_la():
  function test_nested_device_n_color_space (line 594) | def test_nested_device_n_color_space():
  function test_flate_decode_with_image_mode_1 (line 604) | def test_flate_decode_with_image_mode_1():
  function test_flate_decode_with_image_mode_1__whitespace_at_end_of_lookup (line 614) | def test_flate_decode_with_image_mode_1__whitespace_at_end_of_lookup():
  function test_ascii85decode__invalid_end__recoverable (line 623) | def test_ascii85decode__invalid_end__recoverable(caplog):
  function test_ascii85decode__non_recoverable (line 634) | def test_ascii85decode__non_recoverable(caplog):
  function test_ascii85decode__ignore_whitespaces (line 648) | def test_ascii85decode__ignore_whitespaces(caplog):
  function test_ccitt_fax_decode__black_is_1 (line 656) | def test_ccitt_fax_decode__black_is_1():
  function test_flate_decode__image_is_none_due_to_size_limit (line 678) | def test_flate_decode__image_is_none_due_to_size_limit(caplog):
  function test_flate_decode__not_rectangular (line 697) | def test_flate_decode__not_rectangular(caplog):
  function test_jbig2decode__binary_errors (line 714) | def test_jbig2decode__binary_errors():
  function test_jbig2decode__edge_cases (line 747) | def test_jbig2decode__edge_cases(caplog):
  function test_flate_decode_stream_with_faulty_tail_bytes (line 812) | def test_flate_decode_stream_with_faulty_tail_bytes():
  function test_rle_decode_with_faulty_tail_byte_in_multi_encoded_stream (line 835) | def test_rle_decode_with_faulty_tail_byte_in_multi_encoded_stream(caplog):
  function test_rle_decode_exception_with_corrupted_stream (line 854) | def test_rle_decode_exception_with_corrupted_stream(caplog):
  function test_decompress (line 872) | def test_decompress():
  function test_decompress__logging_on_invalid_data (line 901) | def test_decompress__logging_on_invalid_data(caplog):
  function test_ccittfaxdecode__ccf_inline (line 910) | def test_ccittfaxdecode__ccf_inline():
  function test_dctdecode__dct_inline (line 931) | def test_dctdecode__dct_inline():
  function test_deprecate_inline_image_filters (line 986) | def test_deprecate_inline_image_filters():
  function test_flatedecode__columns_is_zero (line 1019) | def test_flatedecode__columns_is_zero():
  function test_runlengthdecode__decode_limit (line 1031) | def test_runlengthdecode__decode_limit():
  function test_asciihexdecode__speed (line 1049) | def test_asciihexdecode__speed():

FILE: tests/test_font.py
  function test_font_descriptor (line 7) | def test_font_descriptor():

FILE: tests/test_forms.py
  function test_form_button__v_value_should_be_name_object (line 12) | def test_form_button__v_value_should_be_name_object():

FILE: tests/test_generic.py
  class ChildDummy (line 53) | class ChildDummy(DictionaryObject):
    method indirect_reference (line 55) | def indirect_reference(self):
  function test_float_object_exception (line 59) | def test_float_object_exception(caplog):
  function test_number_object_exception (line 64) | def test_number_object_exception(caplog):
  function test_number_object_no_exception (line 69) | def test_number_object_no_exception():
  function test_create_string_object_exception (line 73) | def test_create_string_object_exception():
  function test_boolean_object (line 87) | def test_boolean_object(value, expected, tell):
  function test_boolean_object_write (line 95) | def test_boolean_object_write():
  function test_boolean_eq (line 103) | def test_boolean_eq():
  function test_boolean_object_exception (line 118) | def test_boolean_object_exception():
  function test_array_object_exception (line 125) | def test_array_object_exception():
  function test_null_object_exception (line 132) | def test_null_object_exception():
  function test_indirect_object_premature (line 140) | def test_indirect_object_premature(value):
  function test_read_hex_string_from_stream (line 147) | def test_read_hex_string_from_stream():
  function test_read_hex_string_from_stream_exception (line 152) | def test_read_hex_string_from_stream_exception():
  function test_read_string_from_stream_exception (line 159) | def test_read_string_from_stream_exception():
  function test_read_string_from_stream_not_in_escapedict_no_digit (line 166) | def test_read_string_from_stream_not_in_escapedict_no_digit():
  function test_read_string_from_stream_multichar_eol (line 173) | def test_read_string_from_stream_multichar_eol():
  function test_read_string_from_stream_multichar_eol2 (line 178) | def test_read_string_from_stream_multichar_eol2():
  function test_read_string_from_stream_excape_digit (line 183) | def test_read_string_from_stream_excape_digit():
  function test_read_string_from_stream_excape_digit2 (line 188) | def test_read_string_from_stream_excape_digit2():
  function test_name_object (line 193) | def test_name_object(caplog):
  function test_destination_fit_r (line 272) | def test_destination_fit_r():
  function test_destination_fit_v (line 287) | def test_destination_fit_v():
  function test_outline_item_write_to_stream (line 297) | def test_outline_item_write_to_stream():
  function test_encode_pdfdocencoding_keyerror (line 305) | def test_encode_pdfdocencoding_keyerror():
  function test_encode_pdfdocencoding_returns_bytes (line 312) | def test_encode_pdfdocencoding_returns_bytes(test_input):
  function test_read_object_comment_exception (line 321) | def test_read_object_comment_exception():
  function test_read_object_empty (line 329) | def test_read_object_empty():
  function test_read_object_empty_in_array (line 335) | def test_read_object_empty_in_array():
  function test_read_object_invalid (line 344) | def test_read_object_invalid():
  function test_read_object_comment (line 352) | def test_read_object_comment():
  function test_bytestringobject (line 359) | def test_bytestringobject():
  function test_dictionaryobject_key_is_no_pdfobject (line 367) | def test_dictionaryobject_key_is_no_pdfobject():
  function test_dictionaryobject_xmp_meta (line 374) | def test_dictionaryobject_xmp_meta():
  function test_dictionaryobject_value_is_no_pdfobject (line 379) | def test_dictionaryobject_value_is_no_pdfobject():
  function test_dictionaryobject_setdefault_key_is_no_pdfobject (line 386) | def test_dictionaryobject_setdefault_key_is_no_pdfobject():
  function test_dictionaryobject_setdefault_value_is_no_pdfobject (line 393) | def test_dictionaryobject_setdefault_value_is_no_pdfobject():
  function test_dictionaryobject_setdefault_value (line 400) | def test_dictionaryobject_setdefault_value():
  function test_dictionaryobject_read_from_stream (line 405) | def test_dictionaryobject_read_from_stream():
  function test_dictionaryobject_read_from_stream_broken (line 412) | def test_dictionaryobject_read_from_stream_broken():
  function test_dictionaryobject_read_from_stream_unexpected_end (line 423) | def test_dictionaryobject_read_from_stream_unexpected_end():
  function test_dictionaryobject_read_from_stream_stream_no_newline (line 431) | def test_dictionaryobject_read_from_stream_stream_no_newline():
  function test_dictionaryobject_read_from_stream_stream_no_stream_length (line 440) | def test_dictionaryobject_read_from_stream_stream_no_stream_length(stric...
  function test_dictionaryobject_read_from_stream_stream_stream_valid (line 468) | def test_dictionaryobject_read_from_stream_stream_stream_valid(
  function test_rectangleobject (line 488) | def test_rectangleobject():
  function test_textstringobject_exc (line 515) | def test_textstringobject_exc():
  function test_textstringobject_autodetect_utf16 (line 520) | def test_textstringobject_autodetect_utf16():
  function test_textstringobject__numbers_as_input (line 530) | def test_textstringobject__numbers_as_input():
  function test_remove_child_not_in_tree (line 535) | def test_remove_child_not_in_tree():
  function test_remove_child_not_in_that_tree (line 542) | def test_remove_child_not_in_that_tree():
  function test_remove_child_not_found_in_tree (line 556) | def test_remove_child_not_found_in_tree():
  function test_remove_child_found_in_tree (line 573) | def test_remove_child_found_in_tree():
  function test_remove_child_in_tree (line 639) | def test_remove_child_in_tree():
  function test_extract_text (line 693) | def test_extract_text(caplog, url: str, name: str, caplog_content: str):
  function test_text_string_write_to_stream (line 705) | def test_text_string_write_to_stream():
  function test_bool_repr (line 717) | def test_bool_repr(tmp_path):
  function test_issue_997 (line 737) | def test_issue_997(pdf_file_path):
  function test_checkboxradiobuttonattributes_opt (line 758) | def test_checkboxradiobuttonattributes_opt():
  function test_name_object_invalid_decode (line 762) | def test_name_object_invalid_decode():
  function test_indirect_object_invalid_read (line 779) | def test_indirect_object_invalid_read():
  function test_create_string_object_utf16_bom (line 786) | def test_create_string_object_utf16_bom():
  function test_create_string_object_force (line 829) | def test_create_string_object_force():
  function test_float_object_decimal_to_string (line 868) | def test_float_object_decimal_to_string(value, expected):
  function test_cloning (line 872) | def test_cloning(caplog):
  function test_cloning_indirect_obj_keeps_hard_reference (line 917) | def test_cloning_indirect_obj_keeps_hard_reference():
  function test_cloning_null_obj_keeps_hard_reference (line 945) | def test_cloning_null_obj_keeps_hard_reference():
  function test_append_with_indirectobject_not_pointing (line 975) | def test_append_with_indirectobject_not_pointing(caplog):
  function test_iss1615_1673 (line 990) | def test_iss1615_1673():
  function test_destination_withoutzoom (line 1016) | def test_destination_withoutzoom():
  function test_encodedstream_set_data (line 1028) | def test_encodedstream_set_data():
  function test_set_data_2 (line 1067) | def test_set_data_2():
  function test_calling_indirect_objects (line 1083) | def test_calling_indirect_objects():
  function test_indirect_object_page_dimensions (line 1103) | def test_indirect_object_page_dimensions():
  function test_indirect_object_contains (line 1112) | def test_indirect_object_contains():
  function test_indirect_object_iter (line 1119) | def test_indirect_object_iter():
  function test_array_operators (line 1126) | def test_array_operators():
  function test_unitary_extract_inline_buffer_invalid (line 1155) | def test_unitary_extract_inline_buffer_invalid():
  function test_unitary_extract_inline (line 1178) | def test_unitary_extract_inline():
  function test_missing_hashbin (line 1244) | def test_missing_hashbin():
  function test_is_null_or_none (line 1251) | def test_is_null_or_none():
  function test_coverage_arrayobject (line 1266) | def test_coverage_arrayobject():
  function test_coverage_streamobject (line 1282) | def test_coverage_streamobject():
  function test_contentstream_arrayobject_containing_nullobject (line 1306) | def test_contentstream_arrayobject_containing_nullobject(caplog):
  function test_build_link__go_to_action_without_destination (line 1317) | def test_build_link__go_to_action_without_destination():
  function test_dictionaryobject__length_0_stream (line 1326) | def test_dictionaryobject__length_0_stream():

FILE: tests/test_images.py
  function open_image (line 26) | def open_image(path: Union[Path, Image.Image, BytesIO]) -> Image.Image:
  function image_size (line 39) | def image_size(image: Image.Image):
  function image_similarity (line 45) | def image_similarity(
  function test_image_similarity_one (line 83) | def test_image_similarity_one():
  function test_image_similarity_zero (line 90) | def test_image_similarity_zero():
  function test_image_similarity_mid (line 97) | def test_image_similarity_mid():
  function test_image_new_property (line 116) | def test_image_new_property():
  function test_image_extraction (line 220) | def test_image_extraction(src, page_index, image_key, expected):
  function test_get_inline_image_without_xobject_resources (line 230) | def test_get_inline_image_without_xobject_resources():
  function test_get_inline_image_without_xobject_resources_raises_when_missing (line 238) | def test_get_inline_image_without_xobject_resources_raises_when_missing():
  function test_get_xobject_image_without_xobject_resources_raises (line 248) | def test_get_xobject_image_without_xobject_resources_raises():
  function test_loop_in_image_keys (line 260) | def test_loop_in_image_keys():
  function test_devicen_cmyk_black_only (line 268) | def test_devicen_cmyk_black_only():
  function test_bi_in_text (line 284) | def test_bi_in_text():
  function test_cmyk_no_filter (line 294) | def test_cmyk_no_filter():
  function test_separation_1byte_to_rgb_inverted (line 303) | def test_separation_1byte_to_rgb_inverted():
  function test_data_with_lf (line 319) | def test_data_with_lf():
  function test_oserror (line 331) | def test_oserror():
  function test_corrupted_jpeg_iss2266 (line 361) | def test_corrupted_jpeg_iss2266(pdf, pdf_name, images, images_name, filtr):
  function test_large_compressed_image (line 394) | def test_large_compressed_image():
  function test_ff_fe_starting_lut (line 403) | def test_ff_fe_starting_lut():
  function test_inline_image_extraction (line 419) | def test_inline_image_extraction():
  function test_extract_image_from_object (line 488) | def test_extract_image_from_object(caplog):
  function test_extract_jpeg_with_explicit_quality (line 508) | def test_extract_jpeg_with_explicit_quality():
  function test_4bits_images (line 521) | def test_4bits_images(caplog):
  function test_no_filter_with_colorspace_as_list (line 532) | def test_no_filter_with_colorspace_as_list():
  function test_contentstream__read_inline_image__fallback_is_successful (line 542) | def test_contentstream__read_inline_image__fallback_is_successful():
  function test_inline_image_containing_ei_in_body (line 568) | def test_inline_image_containing_ei_in_body():
  function test_jbig2decode (line 589) | def test_jbig2decode():
  function test_jbig2decode__jbig2globals (line 609) | def test_jbig2decode__jbig2globals():
  function test_jbig2decode__memory_limit (line 630) | def test_jbig2decode__memory_limit():
  function test_get_ids_image__resources_is_none (line 655) | def test_get_ids_image__resources_is_none():

FILE: tests/test_javascript.py
  function pdf_file_writer (line 11) | def pdf_file_writer():
  function test_add_js (line 18) | def test_add_js(pdf_file_writer):
  function test_added_js (line 29) | def test_added_js(pdf_file_writer):

FILE: tests/test_merger.py
  function merger_operate (line 15) | def merger_operate(merger):
  function check_outline (line 128) | def check_outline(tmp_path):
  function test_merger_operations_by_traditional_usage_with_writer (line 151) | def test_merger_operations_by_traditional_usage_with_writer(tmp_path):
  function test_merger_operations_by_semi_traditional_usage_with_writer (line 164) | def test_merger_operations_by_semi_traditional_usage_with_writer(tmp_path):
  function test_merger_operation_by_new_usage_with_writer (line 176) | def test_merger_operation_by_new_usage_with_writer(tmp_path):
  function test_merge_page_exception_with_writer (line 186) | def test_merge_page_exception_with_writer():
  function test_merge_page_tuple_with_writer (line 198) | def test_merge_page_tuple_with_writer():
  function test_merge_write_closed_fh_with_writer (line 205) | def test_merge_write_closed_fh_with_writer(pdf_file_path):
  function test_trim_outline_list_with_writer (line 219) | def test_trim_outline_list_with_writer(pdf_file_path):
  function test_zoom_with_writer (line 231) | def test_zoom_with_writer(pdf_file_path):
  function test_zoom_xyz_no_left_with_add_page (line 243) | def test_zoom_xyz_no_left_with_add_page(pdf_file_path):
  function test_zoom_xyz_no_left_with_writer (line 255) | def test_zoom_xyz_no_left_with_writer(pdf_file_path):
  function test_outline_item_with_writer (line 267) | def test_outline_item_with_writer(pdf_file_path):
  function test_trim_outline_with_writer (line 279) | def test_trim_outline_with_writer(pdf_file_path):
  function test1_with_writer (line 291) | def test1_with_writer(pdf_file_path):
  function test_sweep_recursion1_with_writer (line 303) | def test_sweep_recursion1_with_writer(pdf_file_path):
  function test_sweep_recursion2_with_writer (line 333) | def test_sweep_recursion2_with_writer(url, name, pdf_file_path):
  function test_sweep_indirect_list_newobj_is_none_with_writer (line 345) | def test_sweep_indirect_list_newobj_is_none_with_writer(caplog, pdf_file...
  function test_iss1145_with_writer (line 360) | def test_iss1145_with_writer():
  function test_iss1344_with_writer (line 370) | def test_iss1344_with_writer(caplog):
  function test_articles_with_writer (line 383) | def test_articles_with_writer(caplog):
  function test_null_articles_with_writer (line 397) | def test_null_articles_with_writer():
  function test_get_reference (line 404) | def test_get_reference():
  function test_direct_link_preserved (line 410) | def test_direct_link_preserved(pdf_file_path):
  function test_direct_link_preserved_reordering (line 433) | def test_direct_link_preserved_reordering(pdf_file_path):
  function test_direct_link_page_missing (line 459) | def test_direct_link_page_missing(pdf_file_path):
  function test_named_reference_preserved (line 473) | def test_named_reference_preserved(pdf_file_path):
  function test_named_ref_to_page_that_is_gone (line 499) | def test_named_ref_to_page_that_is_gone(pdf_file_path):
  function test_merge__null_destination (line 513) | def test_merge__null_destination():

FILE: tests/test_page.py
  function get_all_sample_files (line 42) | def get_all_sample_files():
  function test_read (line 61) | def test_read(meta):
  function test_page_operations (line 88) | def test_page_operations(pdf_path, password):
  function test_mediabox_expansion_after_rotation (line 139) | def test_mediabox_expansion_after_rotation(
  function test_transformation_equivalence (line 161) | def test_transformation_equivalence():
  function test_transformation_equivalence2 (line 195) | def test_transformation_equivalence2():
  function test_get_user_unit_property (line 246) | def test_get_user_unit_property():
  function compare_dict_objects (line 252) | def compare_dict_objects(d1, d2):
  function test_page_transformations (line 262) | def test_page_transformations():
  function test_compress_content_streams (line 299) | def test_compress_content_streams(pdf_path, password):
  function test_page_properties (line 321) | def test_page_properties():
  function test_page_rotation (line 334) | def test_page_rotation():
  function test_page_indirect_rotation (line 357) | def test_page_indirect_rotation():
  function test_page_scale (line 365) | def test_page_scale():
  function test_add_transformation_on_page_without_contents (line 375) | def test_add_transformation_on_page_without_contents():
  function test_iss_1142 (line 384) | def test_iss_1142():
  function test_extract_text (line 441) | def test_extract_text(url, name):
  function test_extract_text_page_pdf_impossible_decode_xform (line 449) | def test_extract_text_page_pdf_impossible_decode_xform(caplog):
  function test_extract_text_operator_t_star (line 461) | def test_extract_text_operator_t_star():  # L1266, L1267
  function test_extract_text_visitor_callbacks (line 469) | def test_extract_text_visitor_callbacks():
  function test_get_fonts (line 619) | def test_get_fonts(pdf_path, password, embedded, unembedded):
  function test_get_fonts2 (line 631) | def test_get_fonts2():
  function test_annotation_getter (line 668) | def test_annotation_getter():
  function test_annotation_setter (line 709) | def test_annotation_setter(pdf_file_path):
  function test_text_extraction_issue_1091 (line 771) | def test_text_extraction_issue_1091():
  function test_empyt_password_1088 (line 782) | def test_empyt_password_1088():
  function test_old_habibi (line 791) | def test_old_habibi():
  function test_read_link_annotation (line 801) | def test_read_link_annotation():
  function test_no_resources (line 831) | def test_no_resources():
  function test_merge_page_reproducible_with_proc_set (line 840) | def test_merge_page_reproducible_with_proc_set():
  function test_merge_resources (line 915) | def test_merge_resources(apage1, apage2, expected_result, expected_renam...
  function test_merge_page_resources_smoke_test (line 936) | def test_merge_page_resources_smoke_test():
  function test_merge_transformed_page_into_blank (line 1004) | def test_merge_transformed_page_into_blank():
  function test_pages_printing (line 1041) | def test_pages_printing():
  function test_del_pages (line 1051) | def test_del_pages():
  function test_pdf_pages_missing_type (line 1100) | def test_pdf_pages_missing_type():
  function test_merge_with_stream_wrapped_in_save_restore (line 1110) | def test_merge_with_stream_wrapped_in_save_restore():
  function test_compression (line 1123) | def test_compression():
  function test_merge_with_no_resources (line 1161) | def test_merge_with_no_resources():
  function test_get_contents_from_nullobject (line 1171) | def test_get_contents_from_nullobject():
  function test_pos_text_in_textvisitor (line 1182) | def test_pos_text_in_textvisitor():
  function test_pos_text_in_textvisitor2 (line 1200) | def test_pos_text_in_textvisitor2():
  function test_missing_basefont_in_type3 (line 1260) | def test_missing_basefont_in_type3():
  function test_invalid_index (line 1268) | def test_invalid_index():
  function test_negative_index (line 1275) | def test_negative_index():
  function test_get_contents_as_bytes (line 1281) | def test_get_contents_as_bytes():
  function test_recursive_get_page_from_node (line 1292) | def test_recursive_get_page_from_node():
  function test_get_contents__none_type (line 1305) | def test_get_contents__none_type():
  function test_extract_text__none_type (line 1322) | def test_extract_text__none_type():
  function test_scale_by (line 1339) | def test_scale_by():
  function test_box_rendering (line 1364) | def test_box_rendering(tmp_path):
  function test_delete_non_existent_annotations (line 1400) | def test_delete_non_existent_annotations():
  function test_replace_contents_on_reader (line 1409) | def test_replace_contents_on_reader():
  function test_replace_contents_on_reader__indirect_reference (line 1427) | def test_replace_contents_on_reader__indirect_reference():
  function test_merge_page__coverage (line 1441) | def test_merge_page__coverage():
  function test_importing_without_pillow (line 1485) | def test_importing_without_pillow(tmp_path):
  function test_replace_contents__null_object_cloning_error (line 1517) | def test_replace_contents__null_object_cloning_error():
  function test_get_rectangle__size_handling (line 1538) | def test_get_rectangle__size_handling(caplog):

FILE: tests/test_page_labels.py
  function test_number2uppercase_roman_numeral (line 44) | def test_number2uppercase_roman_numeral(number, expected):
  function test_number2lowercase_roman_numeral (line 48) | def test_number2lowercase_roman_numeral():
  function test_number2lowercase_letter (line 64) | def test_number2lowercase_letter(number, expected):
  function test_number2uppercase_letter (line 68) | def test_number2uppercase_letter():
  function test_index2label (line 74) | def test_index2label(caplog):
  function test_index2label_kids (line 111) | def test_index2label_kids():
  function test_index2label_kids__recursive (line 143) | def test_index2label_kids__recursive(caplog):
  function test_get_label_from_nums__empty_nums_list (line 173) | def test_get_label_from_nums__empty_nums_list():
  function test_index2label__empty_kids_list (line 179) | def test_index2label__empty_kids_list():

FILE: tests/test_pagerange.py
  function test_equality (line 7) | def test_equality():
  function test_hash (line 13) | def test_hash():
  function test_str (line 28) | def test_str(page_range, expected):
  function test_repr (line 36) | def test_repr(page_range, expected):
  function test_equality_other_objectc (line 40) | def test_equality_other_objectc():
  function test_idempotency (line 46) | def test_idempotency():
  function test_str_init (line 59) | def test_str_init(range_str, expected):
  function test_str_init_error (line 65) | def test_str_init_error():
  function test_parse_filename_page_ranges (line 83) | def test_parse_filename_page_ranges(params, expected):
  function test_parse_filename_page_ranges_err (line 87) | def test_parse_filename_page_ranges_err():
  function test_addition (line 103) | def test_addition(a, b, expected):
  function test_addition_gap (line 117) | def test_addition_gap(a: PageRange, b: PageRange):
  function test_addition_non_page_range (line 123) | def test_addition_non_page_range():
  function test_addition_stride (line 129) | def test_addition_stride():

FILE: tests/test_papersizes.py
  function test_din_a0_paper_size (line 7) | def test_din_a0_paper_size():
  function test_din_a_aspect_ratio (line 24) | def test_din_a_aspect_ratio(dimensions):
  function test_din_a_size_doubling (line 33) | def test_din_a_size_doubling(dimensions_a, dimensions_b):

FILE: tests/test_pdfa.py
  function is_pdfa1b_compliant (line 13) | def is_pdfa1b_compliant(src: BytesIO):
  function test_pdfa (line 38) | def test_pdfa(src: Path, diagnostic_write_name: Optional[str]):

FILE: tests/test_protocols.py
  class IPdfObjectProtocol (line 5) | class IPdfObjectProtocol(PdfObjectProtocol):
  function test_pdfobjectprotocol (line 9) | def test_pdfobjectprotocol():

FILE: tests/test_reader.py
  function test_get_num_pages (line 48) | def test_get_num_pages(src, num_pages):
  function test_read_metadata (line 89) | def test_read_metadata(pdf_path, expected):
  function test_read_metadata_title_is_utf8 (line 117) | def test_read_metadata_title_is_utf8():
  function test_iss1943 (line 125) | def test_iss1943():
  function test_broken_meta_data (line 148) | def test_broken_meta_data(pdf_path):
  function test_get_annotations (line 168) | def test_get_annotations(src):
  function test_get_attachments (line 185) | def test_get_attachments(src, nb_attachments):
  function test_get_outline (line 206) | def test_get_outline(src, outline_elements):
  function test_get_images (line 233) | def test_get_images(src, expected_images):
  function test_get_images_raw (line 310) | def test_get_images_raw(
  function test_issue297 (line 360) | def test_issue297(caplog):
  function test_get_page_of_encrypted_file (line 383) | def test_get_page_of_encrypted_file(pdffile, password, should_fail):
  function test_get_form (line 423) | def test_get_form(src, expected, expected_get_fields, txt_file_path):
  function test_reading_choice_field_without_opt_key (line 451) | def test_reading_choice_field_without_opt_key():
  function test_get_page_number (line 472) | def test_get_page_number(src, page_number):
  function test_get_page_layout (line 484) | def test_get_page_layout(src, expected):
  function test_get_page_mode (line 497) | def test_get_page_mode(src, expected):
  function test_read_empty (line 503) | def test_read_empty():
  function test_read_malformed_header (line 509) | def test_read_malformed_header(caplog):
  function test_read_malformed_body (line 521) | def test_read_malformed_body():
  function test_read_prev_0_trailer (line 529) | def test_read_prev_0_trailer():
  function test_circular_xref_prev_reference (line 566) | def test_circular_xref_prev_reference(caplog):
  function test_read_missing_startxref (line 602) | def test_read_missing_startxref():
  function test_read_unknown_zero_pages (line 637) | def test_read_unknown_zero_pages(caplog):
  function test_read_encrypted_without_decryption (line 689) | def test_read_encrypted_without_decryption():
  function test_get_destination_page_number (line 697) | def test_get_destination_page_number():
  function test_do_not_get_stuck_on_large_files_without_start_xref (line 706) | def test_do_not_get_stuck_on_large_files_without_start_xref():
  function test_decrypt_when_no_id (line 722) | def test_decrypt_when_no_id():
  function test_reader_properties (line 734) | def test_reader_properties():
  function test_issue604 (line 747) | def test_issue604(caplog, strict):
  function test_decode_permissions (line 781) | def test_decode_permissions():
  function test_user_access_permissions (line 818) | def test_user_access_permissions():
  function test_pages_attribute (line 852) | def test_pages_attribute():
  function test_convert_to_int (line 870) | def test_convert_to_int():
  function test_convert_to_int_error (line 874) | def test_convert_to_int_error():
  function test_iss925 (line 881) | def test_iss925():
  function test_get_object (line 894) | def test_get_object():
  function test_extract_text_hello_world (line 900) | def test_extract_text_hello_world():
  function test_read_path (line 919) | def test_read_path():
  function test_read_not_binary_mode (line 925) | def test_read_not_binary_mode(caplog):
  function test_read_form_416 (line 938) | def test_read_form_416():
  function test_form_topname_with_and_without_acroform (line 947) | def test_form_topname_with_and_without_acroform(caplog):
  function test_extract_text_xref_issue_2 (line 976) | def test_extract_text_xref_issue_2(caplog):
  function test_extract_text_xref_issue_3 (line 991) | def test_extract_text_xref_issue_3(caplog):
  function test_extract_text_pdf15 (line 1004) | def test_extract_text_pdf15():
  function test_extract_text_xref_table_21_bytes_clrf (line 1013) | def test_extract_text_xref_table_21_bytes_clrf():
  function test_get_fields (line 1022) | def test_get_fields():
  function test_get_full_qualified_fields (line 1035) | def test_get_full_qualified_fields():
  function test_get_fields_read_else_block (line 1056) | def test_get_fields_read_else_block():
  function test_get_fields_read_else_block2 (line 1064) | def test_get_fields_read_else_block2():
  function test_get_fields_read_else_block3 (line 1074) | def test_get_fields_read_else_block3():
  function test_metadata_is_none (line 1081) | def test_metadata_is_none():
  function test_get_fields_read_write_report (line 1089) | def test_get_fields_read_write_report(txt_file_path):
  function test_xfa (line 1105) | def test_xfa(src):
  function test_xfa_non_empty (line 1111) | def test_xfa_non_empty():
  function test_header (line 1132) | def test_header(src, pdf_header):
  function test_outline_color (line 1139) | def test_outline_color():
  function test_outline_font_format (line 1145) | def test_outline_font_format():
  function get_outline_property (line 1150) | def get_outline_property(outline, attribute_name: str):
  function test_outline_title_issue_1121 (line 1164) | def test_outline_title_issue_1121():
  function test_outline_count (line 1211) | def test_outline_count():
  function test_outline_missing_title (line 1257) | def test_outline_missing_title(caplog):
  function test_named_destination (line 1287) | def test_named_destination(url, name):
  function test_outline_with_missing_named_destination (line 1293) | def test_outline_with_missing_named_destination():
  function test_outline_with_empty_action (line 1302) | def test_outline_with_empty_action():
  function test_outline_with_invalid_destinations (line 1311) | def test_outline_with_invalid_destinations():
  function test_pdfreader_multiple_definitions (line 1319) | def test_pdfreader_multiple_definitions(caplog):
  function test_wrong_password_error (line 1330) | def test_wrong_password_error():
  function test_get_page_number_by_indirect (line 1339) | def test_get_page_number_by_indirect():
  function test_corrupted_xref_table (line 1345) | def test_corrupted_xref_table():
  function test_reader (line 1358) | def test_reader(caplog):
  function test_zeroing_xref (line 1374) | def test_zeroing_xref():
  function test_thread (line 1386) | def test_thread():
  function test_build_outline_item (line 1402) | def test_build_outline_item(caplog):
  function test_page_labels (line 1448) | def test_page_labels(src, page_labels):
  function test_iss1559 (line 1454) | def test_iss1559():
  function test_iss1652 (line 1463) | def test_iss1652():
  function test_iss1689 (line 1472) | def test_iss1689():
  function test_iss1710 (line 1480) | def test_iss1710():
  function test_broken_file_header (line 1487) | def test_broken_file_header():
  function test_iss1756 (line 1522) | def test_iss1756():
  function test_iss1825 (line 1532) | def test_iss1825():
  function test_iss2082 (line 1541) | def test_iss2082():
  function test_issue_140 (line 1555) | def test_issue_140():
  function test_xyz_with_missing_param (line 1564) | def test_xyz_with_missing_param():
  function test_corrupted_xref (line 1576) | def test_corrupted_xref():
  function test_truncated_xref (line 1584) | def test_truncated_xref(caplog):
  function test_damaged_pdf (line 1592) | def test_damaged_pdf():
  function test_looping_form (line 1607) | def test_looping_form(caplog):
  function test_context_manager_with_stream (line 1632) | def test_context_manager_with_stream():
  function test_iss2761 (line 1669) | def test_iss2761():
  function test_iss2817 (line 1678) | def test_iss2817():
  function test_truncated_files (line 1690) | def test_truncated_files(caplog):
  function test_comments_in_array (line 1714) | def test_comments_in_array(caplog):
  function test_space_in_names_to_continue_processing (line 1729) | def test_space_in_names_to_continue_processing(caplog):
  function test_unbalanced_brackets_in_dictionary_object (line 1775) | def test_unbalanced_brackets_in_dictionary_object(caplog):
  function test_repair_root (line 1784) | def test_repair_root(caplog):
  function test_issue3151 (line 1865) | def test_issue3151(caplog):
  function test_issue2886 (line 1874) | def test_issue2886(caplog):
  function test_infinite_loop_for_length_value (line 1884) | def test_infinite_loop_for_length_value():
  function test_trailer_cannot_be_read (line 1895) | def test_trailer_cannot_be_read():
  function test_read_pdf15_xref_stream (line 1904) | def test_read_pdf15_xref_stream():
  function test_read_standard_xref_table__two_whitespace_characters_between_offset_and_generation (line 1919) | def test_read_standard_xref_table__two_whitespace_characters_between_off...
  function test_root_object_recovery_limit (line 1930) | def test_root_object_recovery_limit(caplog):
  function test_rebuild_xref_table__speed (line 1973) | def test_rebuild_xref_table__speed():
  function test_find_pdf_objects (line 1986) | def test_find_pdf_objects():
  function test_find_pdf_trailers (line 2011) | def test_find_pdf_trailers(data: bytes, expected: list[int]):
  function test_objstm_batch_parse_caches_all_objects (line 2016) | def test_objstm_batch_parse_caches_all_objects():
  function test_objstm_cache_hit_returns_target (line 2030) | def test_objstm_cache_hit_returns_target():
  function test_objstm_skips_cache_for_overridden_objects (line 2045) | def test_objstm_skips_cache_for_overridden_objects():

FILE: tests/test_text_extraction.py
  function test_multi_language (line 26) | def test_multi_language(visitor_text):
  function test_visitor_text_matrices (line 79) | def test_visitor_text_matrices(file_name, constraints):
  function test_issue_2336 (line 110) | def test_issue_2336():
  function test_font_class_to_dict (line 118) | def test_font_class_to_dict():
  function test_uninterpretable_type3_font (line 155) | def test_uninterpretable_type3_font(mock_logger_warning):
  function test_layout_mode_epic_page_fonts (line 168) | def test_layout_mode_epic_page_fonts():
  function test_layout_mode_uncommon_operators (line 176) | def test_layout_mode_uncommon_operators():
  function test_layout_mode_type0_font_widths (line 184) | def test_layout_mode_type0_font_widths():
  function test_layout_mode_indirect_sequence_font_widths (line 197) | def test_layout_mode_indirect_sequence_font_widths(caplog):
  function dummy_visitor_text (line 211) | def dummy_visitor_text(text, ctm, tm, fd, fs):
  function test_layout_mode_warnings (line 216) | def test_layout_mode_warnings(mock_logger_warning):
  function test_space_with_one_unit_smaller_than_font_width (line 229) | def test_space_with_one_unit_smaller_than_font_width():
  function test_space_position_calculation (line 240) | def test_space_position_calculation():
  function test_text_leading_height_unit (line 250) | def test_text_leading_height_unit():
  function test_layout_mode_space_vertically_font_height_weight (line 258) | def test_layout_mode_space_vertically_font_height_weight():
  function test_infinite_loop_arrays (line 294) | def test_infinite_loop_arrays():
  function test_content_stream_is_dictionary_object (line 306) | def test_content_stream_is_dictionary_object(caplog):
  function test_tz_with_no_operands (line 329) | def test_tz_with_no_operands():
  function test_iss3060 (line 341) | def test_iss3060():
  function test_iss3074 (line 352) | def test_iss3074():
  function test_layout_mode_text_state (line 363) | def test_layout_mode_text_state():
  function test_rotated_line_wrap (line 380) | def test_rotated_line_wrap():
  function test_layout_mode_warns_on_malformed_content_stream (line 401) | def test_layout_mode_warns_on_malformed_content_stream(op, msg, caplog):
  function test_process_operation__cm_multiplication_issue (line 408) | def test_process_operation__cm_multiplication_issue():
  function test_rotated_layout_mode (line 421) | def test_rotated_layout_mode(caplog):
  function test_extract_text__none_objects (line 438) | def test_extract_text__none_objects():
  function test_extract_text__with_visitor_text (line 448) | def test_extract_text__with_visitor_text():
  function test_extract_text__restore_cm_stack_pop_error (line 465) | def test_extract_text__restore_cm_stack_pop_error():
  function test_slow_huge_string (line 480) | def test_slow_huge_string():
  function test_extract_text_with_missing_font_bbox (line 492) | def test_extract_text_with_missing_font_bbox():

FILE: tests/test_utils.py
  function test_skip_over_whitespace (line 54) | def test_skip_over_whitespace(stream, expected):
  function test_check_if_whitespace_only (line 72) | def test_check_if_whitespace_only(value, expected):
  function test_read_until_whitespace (line 76) | def test_read_until_whitespace():
  function test_skip_over_comment (line 89) | def test_skip_over_comment(stream, remainder):
  function test_read_until_regex_premature_ending_name (line 94) | def test_read_until_regex_premature_ending_name():
  function test_read_until_regex_match_in_first_chunk (line 99) | def test_read_until_regex_match_in_first_chunk():
  function test_read_until_regex_match_in_second_chunk (line 107) | def test_read_until_regex_match_in_second_chunk():
  function test_read_until_regex_match_at_chunk_boundary (line 118) | def test_read_until_regex_match_at_chunk_boundary():
  function test_read_until_regex_multi_byte_spanning_boundary (line 129) | def test_read_until_regex_multi_byte_spanning_boundary():
  function test_read_until_regex_no_match_exhausted (line 141) | def test_read_until_regex_no_match_exhausted():
  function test_read_until_regex_exponential_chunk_growth (line 149) | def test_read_until_regex_exponential_chunk_growth():
  function test_read_until_regex_match_spanning_later_boundary (line 160) | def test_read_until_regex_match_spanning_later_boundary():
  function test_read_until_regex_tail_overlap_is_fixed (line 173) | def test_read_until_regex_tail_overlap_is_fixed():
  function test_matrix_multiply (line 201) | def test_matrix_multiply(a, b, expected):
  function test_mark_location (line 205) | def test_mark_location():
  function test_deprecate_no_replacement (line 211) | def test_deprecate_no_replacement():
  function test_read_block_backwards (line 234) | def test_read_block_backwards(dat, pos, to_read, expected, expected_pos):
  function test_read_block_backwards_at_start (line 245) | def test_read_block_backwards_at_start():
  function test_read_previous_line (line 266) | def test_read_previous_line(dat, pos, expected, expected_pos):
  function test_read_previous_line2 (line 274) | def test_read_previous_line2():
  function test_get_max_pdf_version_header (line 300) | def test_get_max_pdf_version_header():
  function test_read_block_backwards_exception (line 306) | def test_read_block_backwards_exception():
  function test_deprecate_with_replacement (line 314) | def test_deprecate_with_replacement():
  function test_deprecation_no_replacement (line 325) | def test_deprecation_no_replacement():
  function test_logger_error (line 336) | def test_logger_error(caplog):
  function test_rename_kwargs (line 347) | def test_rename_kwargs():
  function test_rename_kwargs__stacklevel (line 385) | def test_rename_kwargs__stacklevel(tmp_path: Path) -> None:
  function test_human_readable_bytes (line 431) | def test_human_readable_bytes(input_int, expected_output):
  function test_file_class (line 436) | def test_file_class():
  function test_parse_datetime (line 461) | def test_parse_datetime(text, expected):
  function test_parse_datetime_edge_cases (line 474) | def test_parse_datetime_edge_cases(text, expected):
  function test_parse_datetime_err (line 479) | def test_parse_datetime_err():
  function test_format_iso8824_date (line 486) | def test_format_iso8824_date():
  function test_format_iso8824_date_roundtrip (line 505) | def test_format_iso8824_date_roundtrip():
  function test_is_sublist (line 527) | def test_is_sublist():
  function test_version_compare (line 573) | def test_version_compare(left, right, is_less_than):
  function test_version_compare_equal_str (line 577) | def test_version_compare_equal_str():
  function test_version_compare_lt_str (line 582) | def test_version_compare_lt_str():
  function test_bad_version (line 589) | def test_bad_version():
  function test_version_eq_hash (line 593) | def test_version_eq_hash():
  function test_classproperty (line 603) | def test_classproperty():

FILE: tests/test_workflows.py
  function test_basic_features (line 32) | def test_basic_features(tmp_path):
  function test_dropdown_items (line 80) | def test_dropdown_items():
  function test_pdfreader_file_load (line 87) | def test_pdfreader_file_load():
  function test_pdfreader_jpeg_image (line 113) | def test_pdfreader_jpeg_image():
  function test_decrypt (line 136) | def test_decrypt():
  function test_text_extraction_encrypted (line 151) | def test_text_extraction_encrypted():
  function test_rotate (line 165) | def test_rotate(degree):
  function test_rotate_45 (line 172) | def test_rotate_45():
  function test_extract_textbench (line 248) | def test_extract_textbench(enable, url, pages):
  function test_transform_compress_identical_objects (line 264) | def test_transform_compress_identical_objects():
  function test_orientations (line 281) | def test_orientations():
  function test_overlay (line 330) | def test_overlay(pdf_file_path, base_path, overlay_path):
  function test_merge_with_warning (line 358) | def test_merge_with_warning(tmp_path, url, name):
  function test_merge (line 378) | def test_merge(tmp_path, url, name):
  function test_get_metadata (line 405) | def test_get_metadata(url, name, expected_metadata):
  function test_extract_text (line 484) | def test_extract_text(url, name, strict, exception):
  function test_compress_raised (line 524) | def test_compress_raised(url, name):
  function test_get_fields_warns (line 544) | def test_get_fields_warns(tmp_path, caplog, url, name):
  function test_get_fields_no_warning (line 569) | def test_get_fields_no_warning(tmp_path, url, name):
  function test_scale_rectangle_indirect_object (line 580) | def test_scale_rectangle_indirect_object():
  function test_merge_output (line 590) | def test_merge_output(caplog):
  function test_image_extraction (line 665) | def test_image_extraction(url, name):
  function test_image_extraction_strict (line 691) | def test_image_extraction_strict():
  function test_image_extraction2 (line 728) | def test_image_extraction2(url, name):
  function test_get_outline (line 766) | def test_get_outline(url, name):
  function test_get_xfa (line 786) | def test_get_xfa(url, name):
  function test_get_fonts (line 818) | def test_get_fonts(url, name, strict):
  function test_get_xmp (line 851) | def test_get_xmp(url, name, strict):
  function test_tounicode_is_identity (line 884) | def test_tounicode_is_identity():
  function test_append_forms (line 893) | def test_append_forms():
  function test_extra_test_iss1541 (line 918) | def test_extra_test_iss1541():
  function test_fields_returning_stream (line 949) | def test_fields_returning_stream():
  function test_replace_image (line 958) | def test_replace_image(tmp_path):
  function test_inline_images (line 1003) | def test_inline_images():
  function test_issue1899 (line 1041) | def test_issue1899():
  function test_cr_with_cm_operation (line 1051) | def test_cr_with_cm_operation():
  function remove_trailing_whitespace (line 1068) | def remove_trailing_whitespace(text: str) -> str:
  function test_text_extraction_layout_mode (line 1087) | def test_text_extraction_layout_mode(pdf_path, expected_path):
  function test_layout_mode_space_vertically (line 1096) | def test_layout_mode_space_vertically():
  function test_layout_mode_rotations (line 1111) | def test_layout_mode_rotations(rotation, strip_rotated):
  function test_text_extraction_invalid_mode (line 1129) | def test_text_extraction_invalid_mode():
  function test_get_page_showing_field (line 1137) | def test_get_page_showing_field():
  function test_extract_empty_page (line 1294) | def test_extract_empty_page():
  function test_iss2815 (line 1303) | def test_iss2815():

FILE: tests/test_writer.py
  function _get_write_target (line 47) | def _get_write_target(convert) -> Any:
  function test_writer_exception_non_binary (line 55) | def test_writer_exception_non_binary(tmp_path, caplog):
  function test_writer_clone (line 68) | def test_writer_clone():
  function test_clone_metadata (line 81) | def test_clone_metadata():
  function test_writer_clone_bookmarks (line 109) | def test_writer_clone_bookmarks():
  function writer_operate (line 151) | def writer_operate(writer: PdfWriter) -> None:
  function test_insert_blank_page (line 258) | def test_insert_blank_page():
  function test_writer_operations_by_traditional_usage (line 348) | def test_writer_operations_by_traditional_usage(convert, needs_cleanup):
  function test_writer_operations_by_semi_traditional_usage (line 373) | def test_writer_operations_by_semi_traditional_usage(convert, needs_clea...
  function test_writer_operations_by_semi_new_traditional_usage (line 399) | def test_writer_operations_by_semi_new_traditional_usage(convert, needs_...
  function test_writer_operation_by_new_usage (line 420) | def test_writer_operation_by_new_usage(convert, needs_cleanup):
  function test_remove_images (line 438) | def test_remove_images(pdf_file_path, input_path):
  function test_remove_images_sub_level (line 463) | def test_remove_images_sub_level():
  function test_remove_text (line 490) | def test_remove_text(input_path, pdf_file_path):
  function test_remove_text_all_operators (line 505) | def test_remove_text_all_operators(pdf_file_path):
  function test_write_metadata (line 567) | def test_write_metadata(pdf_file_path):
  function test_fill_form (line 592) | def test_fill_form(pdf_file_path):
  function test_fill_form_with_qualified (line 617) | def test_fill_form_with_qualified():
  function test_encrypt (line 639) | def test_encrypt(use_128bit, user_password, owner_password, pdf_file_path):
  function test_add_outline_item (line 693) | def test_add_outline_item(pdf_file_path):
  function test_add_named_destination (line 746) | def test_add_named_destination(pdf_file_path):
  function test_add_named_destination_sort_order (line 783) | def test_add_named_destination_sort_order(pdf_file_path):
  function test_add_uri (line 811) | def test_add_uri(pdf_file_path):
  function test_link_annotation (line 848) | def test_link_annotation(pdf_file_path):
  function test_io_streams (line 902) | def test_io_streams():
  function test_regression_issue670 (line 918) | def test_regression_issue670(pdf_file_path):
  function test_issue301 (line 928) | def test_issue301():
  function test_append_pages_from_reader_append (line 938) | def test_append_pages_from_reader_append():
  function test_sweep_indirect_references_nullobject_exception (line 951) | def test_sweep_indirect_references_nullobject_exception(pdf_file_path):
  function test_some_appends (line 978) | def test_some_appends(pdf_file_path, url, name):
  function test_pdf_header (line 985) | def test_pdf_header():
  function test_write_dict_stream_object (line 997) | def test_write_dict_stream_object(pdf_file_path):
  function test_add_single_annotation (line 1041) | def test_add_single_annotation(pdf_file_path):
  function test_colors_in_outline_item (line 1071) | def test_colors_in_outline_item(pdf_file_path):
  function test_write_empty_stream (line 1092) | def test_write_empty_stream():
  function test_startup_dest (line 1102) | def test_startup_dest():
  function test_iss471 (line 1144) | def test_iss471():
  function test_reset_translation (line 1157) | def test_reset_translation():
  function test_threads_empty (line 1185) | def test_threads_empty():
  function test_append_without_annots_and_articles (line 1195) | def test_append_without_annots_and_articles():
  function test_append_multiple (line 1214) | def test_append_multiple():
  function test_set_page_label (line 1229) | def test_set_page_label(pdf_file_path):
  function test_iss1601 (line 1364) | def test_iss1601():
  function test_attachments (line 1386) | def test_attachments():
  function test_iss1614 (line 1433) | def test_iss1614():
  function test_new_removes (line 1448) | def test_new_removes():
  function test_late_iss1654 (line 1536) | def test_late_iss1654():
  function test_iss1723 (line 1549) | def test_iss1723():
  function test_iss1767 (line 1559) | def test_iss1767():
  function test_named_dest_page_number (line 1570) | def test_named_dest_page_number():
  function test_update_form_fields (line 1595) | def test_update_form_fields(caplog, tmp_path):
  function test_add_apstream_object (line 1676) | def test_add_apstream_object():
  function test_merge_content_stream_to_page (line 1704) | def test_merge_content_stream_to_page():
  function test_update_form_fields2 (line 1736) | def test_update_form_fields2(caplog):
  function test_iss1862 (line 1818) | def test_iss1862():
  function test_empty_objects_before_cloning (line 1830) | def test_empty_objects_before_cloning():
  function test_watermark (line 1845) | def test_watermark():
  function test_watermarking_speed (line 1865) | def test_watermarking_speed():
  function test_watermark_rendering (line 1882) | def test_watermark_rendering(tmp_path):
  function test_watermarking_reportlab_rendering (line 1919) | def test_watermarking_reportlab_rendering(tmp_path):
  function test_da_missing_in_annot (line 1957) | def test_da_missing_in_annot():
  function test_missing_fields (line 1983) | def test_missing_fields(pdf_file_path):
  function test_missing_info (line 2005) | def test_missing_info():
  function test_germanfields (line 2040) | def test_germanfields():
  function test_no_t_in_articles (line 2063) | def test_no_t_in_articles():
  function test_no_i_in_articles (line 2073) | def test_no_i_in_articles():
  function test_damaged_pdf_length_returning_none (line 2083) | def test_damaged_pdf_length_returning_none():
  function test_viewerpreferences (line 2096) | def test_viewerpreferences():
  function test_extra_spaces_in_da_text (line 2164) | def test_extra_spaces_in_da_text(caplog):
  function test_object_contains_indirect_reference_to_self (line 2179) | def test_object_contains_indirect_reference_to_self():
  function test_remove_image_per_type (line 2190) | def test_remove_image_per_type():
  function test_add_outlines_on_empty_dict (line 2220) | def test_add_outlines_on_empty_dict():
  function test_merging_many_temporary_files (line 2299) | def test_merging_many_temporary_files(caplog):
  function test_reattach_fields (line 2366) | def test_reattach_fields():
  function test_get_pagenumber_from_indirectobject (line 2398) | def test_get_pagenumber_from_indirectobject():
  function test_replace_object (line 2411) | def test_replace_object():
  function test_mime_jupyter (line 2436) | def test_mime_jupyter():
  function test_init_without_named_arg (line 2444) | def test_init_without_named_arg():
  function test_i_in_choice_fields (line 2466) | def test_i_in_choice_fields():
  function test_selfont (line 2478) | def test_selfont():
  function test_no_resource_for_14_std_fonts (line 2502) | def test_no_resource_for_14_std_fonts():
  function test_field_box_upside_down (line 2518) | def test_field_box_upside_down():
  function test_matrix_entry_in_field_annots (line 2535) | def test_matrix_entry_in_field_annots():
  function test_compress_identical_objects (line 2549) | def test_compress_identical_objects():
  function test_set_need_appearances_writer (line 2571) | def test_set_need_appearances_writer():
  function test_utf16_metadata (line 2577) | def test_utf16_metadata():
  function test_increment_writer (line 2599) | def test_increment_writer(caplog):
  function test_append_pdf_with_dest_without_page (line 2693) | def test_append_pdf_with_dest_without_page(caplog):
  function test_destination_is_nullobject (line 2705) | def test_destination_is_nullobject():
  function test_destination_page_is_none (line 2715) | def test_destination_page_is_none():
  function test_stream_not_closed (line 2724) | def test_stream_not_closed():
  function test_auto_write (line 2744) | def test_auto_write(tmp_path):
  function test_deprecate_with_as (line 2752) | def test_deprecate_with_as():
  function test_inline_image_q_operator_handling (line 2770) | def test_inline_image_q_operator_handling(tmp_path):
  function test_insert_filtered_annotations__annotations_are_none (line 2805) | def test_insert_filtered_annotations__annotations_are_none():
  function test_incremental_read (line 2816) | def test_incremental_read():
  function test_compress_identical_objects__after_remove_images (line 2850) | def test_compress_identical_objects__after_remove_images():
  function test_merge__process_named_dests__no_dests_in_source_file (line 2857) | def test_merge__process_named_dests__no_dests_in_source_file():
  function test_insert_filtered_annotations__link_without_destination (line 2876) | def test_insert_filtered_annotations__link_without_destination():
  function test_insert_filtered_annotations__annotations_are_no_list (line 2907) | def test_insert_filtered_annotations__annotations_are_no_list(caplog):
  function test_unterminated_object__with_incremental_writer (line 2935) | def test_unterminated_object__with_incremental_writer():
  function test_wrong_size_in_incremental_pdf (line 2948) | def test_wrong_size_in_incremental_pdf(caplog):
  function test_flatten_form_field_without_font_in_resources (line 2971) | def test_flatten_form_field_without_font_in_resources():
  function test_merge_with_null_acroform_does_not_raise_typeerror (line 2992) | def test_merge_with_null_acroform_does_not_raise_typeerror():
  function test_compress_identical_objects__info_is_none (line 3014) | def test_compress_identical_objects__info_is_none():
  function test_flatten_form_field_with_signature (line 3023) | def test_flatten_form_field_with_signature():

FILE: tests/test_xmp.py
  function test_read_xmp_metadata_samples (line 24) | def test_read_xmp_metadata_samples(src):
  function test_writer_xmp_metadata_samples (line 42) | def test_writer_xmp_metadata_samples():
  function test_read_xmp_metadata (line 78) | def test_read_xmp_metadata(src, has_xmp):
  function get_all_tiff (line 93) | def get_all_tiff(xmp: pypdf.xmp.XmpInformation):
  function test_converter_date (line 105) | def test_converter_date():
  function test_modify_date (line 122) | def test_modify_date():
  function test_identity_function (line 137) | def test_identity_function(x):
  function test_xmpmm_instance_id (line 153) | def test_xmpmm_instance_id(url, name, xmpmm_instance_id):
  function test_xmp_dc_description_extraction (line 163) | def test_xmp_dc_description_extraction():
  function test_dc_creator_extraction (line 179) | def test_dc_creator_extraction():
  function test_custom_properties_extraction (line 191) | def test_custom_properties_extraction():
  function test_dc_subject_extraction (line 203) | def test_dc_subject_extraction():
  function test_invalid_xmp_information_handling (line 235) | def test_invalid_xmp_information_handling():
  function test_pdfa_xmp_metadata_with_values (line 249) | def test_pdfa_xmp_metadata_with_values():
  function test_pdfa_xmp_metadata_without_values (line 260) | def test_pdfa_xmp_metadata_without_values():
  function test_xmp_metadata__content_stream_is_dictionary_object (line 271) | def test_xmp_metadata__content_stream_is_dictionary_object():
  function test_dc_creator__bag_instead_of_seq (line 284) | def test_dc_creator__bag_instead_of_seq():
  function test_dc_language__no_bag_container (line 294) | def test_dc_language__no_bag_container():
  function test_reading_does_not_destroy_root_object (line 301) | def test_reading_does_not_destroy_root_object():
  function test_xmp_information__write_to_stream (line 315) | def test_xmp_information__write_to_stream():
  function test_pdf_writer__xmp_metadata_setter (line 332) | def test_pdf_writer__xmp_metadata_setter():
  function test_xmp_information__create (line 389) | def test_xmp_information__create():
  function test_xmp_information__set_dc_title (line 400) | def test_xmp_information__set_dc_title():
  function test_xmp_information__set_dc_creator (line 412) | def test_xmp_information__set_dc_creator():
  function test_xmp_information__set_dc_description (line 424) | def test_xmp_information__set_dc_description():
  function test_xmp_information__set_dc_subject (line 436) | def test_xmp_information__set_dc_subject():
  function test_xmp_information__set_dc_date (line 448) | def test_xmp_information__set_dc_date():
  function test_xmp_information__set_single_fields (line 466) | def test_xmp_information__set_single_fields():
  function test_xmp_information__set_bag_fields (line 491) | def test_xmp_information__set_bag_fields():
  function test_xmp_information__set_dc_rights (line 526) | def test_xmp_information__set_dc_rights():
  function test_xmp_information__set_pdf_fields (line 538) | def test_xmp_information__set_pdf_fields():
  function test_xmp_information__set_xmp_date_fields (line 558) | def test_xmp_information__set_xmp_date_fields():
  function test_xmp_information__set_xmp_creator_tool (line 592) | def test_xmp_information__set_xmp_creator_tool():
  function test_xmp_information__set_xmpmm_fields (line 602) | def test_xmp_information__set_xmpmm_fields():
  function test_xmp_information__set_pdfaid_fields (line 619) | def test_xmp_information__set_pdfaid_fields():
  function test_xmp_information__create_with_writer (line 634) | def test_xmp_information__create_with_writer():
  function test_xmp_information__namespace_prefix (line 657) | def test_xmp_information__namespace_prefix():
  function test_xmp_information__owner_document_none_errors (line 670) | def test_xmp_information__owner_document_none_errors():
  function test_xmp_information__remove_existing_attribute (line 752) | def test_xmp_information__remove_existing_attribute():
  function test_xmp_information__edge_case_coverage (line 779) | def test_xmp_information__edge_case_coverage():
  function test_xmp_information__create_new_description (line 801) | def test_xmp_information__create_new_description():
  function test_xmp_information__get_text_skips_non_text_nodes (line 815) | def test_xmp_information__get_text_skips_non_text_nodes():
  function test_xmp_information__get_or_create_description_mismatch_about_uri (line 827) | def test_xmp_information__get_or_create_description_mismatch_about_uri():
  function test_xmp_information__attribute_handling (line 842) | def test_xmp_information__attribute_handling():
  function test_xmp_information__create_and_set_metadata (line 868) | def test_xmp_information__create_and_set_metadata():
  function test_xmp_information__external_entity_expansion (line 892) | def test_xmp_information__external_entity_expansion(tmpdir):
  function test_xmp_information__exponential_entity_expansion (line 914) | def test_xmp_information__exponential_entity_expansion():

FILE: tests/utils.py
  class PositionedText (line 11) | class PositionedText:
    method __init__ (line 18) | def __init__(self, text, x, y, font_dict, font_size) -> None:
    method get_base_font (line 26) | def get_base_font(self) -> str:
  class Rectangle (line 37) | class Rectangle:
    method __init__ (line 40) | def __init__(self, x, y, w, h) -> None:
    method contains (line 46) | def contains(self, x, y) -> bool:
  function extract_text_and_rectangles (line 53) | def extract_text_and_rectangles(
  function extract_table (line 104) | def extract_table(
  function extract_cell_text (line 186) | def extract_cell_text(cell_texts: list[PositionedText]) -> str:
  function get_image_data (line 191) | def get_image_data(
  class ReaderDummy (line 201) | class ReaderDummy:
    method __init__ (line 202) | def __init__(self, strict=False) -> None:
    method get_object (line 205) | def get_object(self, indirect_reference):
    method get_reference (line 212) | def get_reference(self, obj):

[
  {
    "path": ".git-blame-ignore-revs",
    "chars": 488,
    "preview": "# This file helps us to ignore style / formatting / doc changes\n# in git blame. That is useful when we're trying to find"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug-report.md",
    "chars": 743,
    "preview": "---\nname: Report a bug\nabout: Something broke!\ntitle: ''\nlabels: Bug\nassignees: ''\n\n---\n\nReplace this: What happened? Wh"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature-request.md",
    "chars": 365,
    "preview": "---\nname: Request a Feature\nabout: What do you think is missing in pypdf?\ntitle: ''\nlabels: Feature Request\nassignees: '"
  },
  {
    "path": ".github/SECURITY.md",
    "chars": 1105,
    "preview": "# Security Policy\n\n## Supported Versions\n\nSecurity fixes are applied to the latest version.\n\n## Reporting a Vulnerabilit"
  },
  {
    "path": ".github/dependabot.yaml",
    "chars": 200,
    "preview": "# Set update schedule for GitHub Actions\n\nversion: 2\nupdates:\n\n  - package-ecosystem: \"github-actions\"\n    directory: \"/"
  },
  {
    "path": ".github/scripts/check_gh_pages_updates.py",
    "chars": 3087,
    "preview": "\"\"\"Check that all GitHub pages JavaScript dependencies are up-to-date.\"\"\"  # noqa: INP001\n\nimport base64\nimport hashlib\n"
  },
  {
    "path": ".github/scripts/check_pr_title.py",
    "chars": 893,
    "preview": "\"\"\"Check that all PR titles follow the desired scheme.\"\"\"  # noqa: INP001\n\nimport os\nimport sys\n\nKNOWN_PREFIXES = (\n    "
  },
  {
    "path": ".github/scripts/check_urls.py",
    "chars": 2685,
    "preview": "\"\"\"Check that all test data URLs are still accessible.\"\"\"  # noqa: INP001\nimport ast\nimport sys\nfrom collections.abc imp"
  },
  {
    "path": ".github/workflows/benchmark.yaml",
    "chars": 1513,
    "preview": "name: Benchmarking pypdf\non:\n  push:\n    branches:\n      - main\n\npermissions:\n  contents: write\n  deployments: write\n\njo"
  },
  {
    "path": ".github/workflows/create-github-release.yaml",
    "chars": 1126,
    "preview": "name: Create a GitHub release page\n\non:\n  push:\n    tags:\n      - '*.*.*'\n  workflow_dispatch:\n\npermissions:\n  contents:"
  },
  {
    "path": ".github/workflows/gh-pages-check.yaml",
    "chars": 706,
    "preview": "name: 'GitHub Pages Check'\non:\n  workflow_dispatch:\n  schedule:\n    - cron: 0 6 * * 1\n\njobs:\n  url-check:\n    name: GitH"
  },
  {
    "path": ".github/workflows/github-ci.yaml",
    "chars": 10893,
    "preview": "# This workflow will install Python dependencies, run tests and lint with a variety of Python versions\n# For more inform"
  },
  {
    "path": ".github/workflows/publish-to-pypi.yaml",
    "chars": 1197,
    "preview": "name: Publish Python Package to PyPI\n\non:\n  push:\n    tags:\n      - '*.*.*'\n  workflow_dispatch:\n\njobs:\n  build:\n    nam"
  },
  {
    "path": ".github/workflows/release.yaml",
    "chars": 1941,
    "preview": "# This action assumes that there is a REL-commit which already has a\n# Markdown-formatted git tag. Hence, the CHANGELOG "
  },
  {
    "path": ".github/workflows/title-check.yaml",
    "chars": 533,
    "preview": "name: 'PR Title Check'\non:\n  pull_request:\n    # check when PR\n    # * is created,\n    # * title is edited, and\n    # * "
  },
  {
    "path": ".github/workflows/urls-check.yaml",
    "chars": 547,
    "preview": "name: 'URL Check'\non:\n  workflow_dispatch:\n  schedule:\n    - cron: 0 6 * * 1\n\njobs:\n  url-check:\n    name: URL check\n   "
  },
  {
    "path": ".gitignore",
    "chars": 513,
    "preview": "*.pyc\n*.swp\n.DS_Store\n.tox\nbuild\n.idea/*\n*.egg-info/\ndist/*\n__pycache__/\n\n# in-project virtual environments\nvenv/\n.venv/"
  },
  {
    "path": ".gitmodules",
    "chars": 94,
    "preview": "[submodule \"sample-files\"]\n\tpath = sample-files\n\turl = https://github.com/py-pdf/sample-files\n"
  },
  {
    "path": ".pre-commit-config.yaml",
    "chars": 941,
    "preview": "# pre-commit run --all-files\nrepos:\n-   repo: https://github.com/pre-commit/pre-commit-hooks\n    rev: v6.0.0\n    hooks:\n"
  },
  {
    "path": ".readthedocs.yaml",
    "chars": 551,
    "preview": "# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details\nversion: 2\n\n\nbuild:\n  os: ubuntu-lts-latest\n"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 73651,
    "preview": "# CHANGELOG\n\n## Version 6.9.1, 2026-03-17\n\n### Security (SEC)\n- Improve performance and limit length of array-based cont"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 1367,
    "preview": "Please check the [documentation page dedicated to development](https://pypdf.readthedocs.io/en/stable/dev/intro.html).\n\n"
  },
  {
    "path": "CONTRIBUTORS.md",
    "chars": 5107,
    "preview": "# Contributors\n\npypdf had a lot of contributors since it started as pyPdf in 2005. We are\na free software project withou"
  },
  {
    "path": "LICENSE",
    "chars": 1605,
    "preview": "Copyright (c) 2006-2008, Mathieu Fenniak\nSome contributions copyright (c) 2007, Ashish Kulkarni <kulkarni.ashish@gmail.c"
  },
  {
    "path": "Makefile",
    "chars": 774,
    "preview": "maint:\n\tpre-commit autoupdate\n\tpip-compile -U requirements/ci.in\n\tpip-compile -U requirements/dev.in\n\tpip-compile -U req"
  },
  {
    "path": "README.md",
    "chars": 4858,
    "preview": "[![PyPI version](https://badge.fury.io/py/pypdf.svg)](https://badge.fury.io/py/pypdf)\n[![Python Support](https://img.shi"
  },
  {
    "path": "docs/Makefile",
    "chars": 634,
    "preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line, and also\n# from the "
  },
  {
    "path": "docs/_static/releasing.drawio",
    "chars": 10286,
    "preview": "<mxfile host=\"Electron\" type=\"device\">\n  <diagram name=\"Seite-1\" id=\"xmn08oupI2gSAHxAwkuE\">\n    <mxGraphModel dx=\"394\" d"
  },
  {
    "path": "docs/conf.py",
    "chars": 7829,
    "preview": "\"\"\"\nConfiguration file for the Sphinx documentation builder.\n\nThis file only contains a selection of the most common opt"
  },
  {
    "path": "docs/dev/cmaps.md",
    "chars": 1068,
    "preview": "# CMaps\n\nLooking at the cmap of \"crazyones\":\n\n```bash\npdftk crazyones.pdf output crazyones-uncomp.pdf uncompress\n```\n\nYo"
  },
  {
    "path": "docs/dev/deprecations.md",
    "chars": 1955,
    "preview": "# The Deprecation Process\n\npypdf strives to be an excellent library for its current users and for new\nones. We are caref"
  },
  {
    "path": "docs/dev/documentation.md",
    "chars": 2735,
    "preview": "# Documentation\n\nThis documentation is build with [Sphinx](https://www.sphinx-doc.org/) and\nhosted by [Read the Docs](ht"
  },
  {
    "path": "docs/dev/intro.md",
    "chars": 4551,
    "preview": "# Developer Intro\n\npypdf is a library and hence its users are developers. This document is not for\nthe users, but for pe"
  },
  {
    "path": "docs/dev/pdf-format.md",
    "chars": 4770,
    "preview": "# The PDF Format\n\nIt is recommended to look in the PDF specification for details and clarifications.\n\n* [PDF Specificati"
  },
  {
    "path": "docs/dev/pypdf-parsing.md",
    "chars": 1646,
    "preview": "# How pypdf parses PDF files\n\npypdf uses {class}`~pypdf.PdfReader` to parse PDF files.\nThe method {py:meth}`PdfReader.re"
  },
  {
    "path": "docs/dev/pypdf-writing.md",
    "chars": 3895,
    "preview": "# How pypdf writes PDF files\n\npypdf uses {py:class}`PdfWriter <pypdf.PdfWriter>` to write PDF files. pypdf has\n{py:class"
  },
  {
    "path": "docs/dev/releasing.md",
    "chars": 2501,
    "preview": "# Releasing\n\nA `pypdf` release contains the following artifacts:\n\n* A new [release on PyPI](https://pypi.org/project/pyp"
  },
  {
    "path": "docs/dev/testing.md",
    "chars": 2369,
    "preview": "# Testing\n\npypdf uses [`pytest`](https://docs.pytest.org/en/7.1.x/) for testing.\n\nTo run the tests, you need to install "
  },
  {
    "path": "docs/index.rst",
    "chars": 2386,
    "preview": ".. pypdf documentation main file, created by\n   sphinx-quickstart on Thu Apr  7 20:13:19 2022.\n   You can adapt this fil"
  },
  {
    "path": "docs/make.bat",
    "chars": 800,
    "preview": "@ECHO OFF\r\n\r\npushd %~dp0\r\n\r\nREM Command file for Sphinx documentation\r\n\r\nif \"%SPHINXBUILD%\" == \"\" (\r\n\tset SPHINXBUILD=sp"
  },
  {
    "path": "docs/meta/changelog-v1.md",
    "chars": 33978,
    "preview": "# Changelog of PyPDF2 1.X\n\n## Version 1.28.4, 2022-05-29\n\nBug Fixes (BUG):\n-  XmpInformation._converter_date was unusabl"
  },
  {
    "path": "docs/meta/comparisons.md",
    "chars": 3746,
    "preview": "# pypdf vs X\n\npypdf is a [free] and open source pure-python PDF library capable of\nsplitting, merging, cropping, and tra"
  },
  {
    "path": "docs/meta/faq.md",
    "chars": 2946,
    "preview": "# Frequently Asked Questions\n\n## How is pypdf related to PyPDF2?\n\nPyPDF2 was a fork from the original pyPdf. After sever"
  },
  {
    "path": "docs/meta/history.md",
    "chars": 3529,
    "preview": "# History of pypdf\n\n## The Origins: pyPdf (2005-2010)\n\nIn 2005, [Mathieu Fenniak] launched pyPdf \"as a PDF toolkit...\"\nf"
  },
  {
    "path": "docs/meta/migration-1-to-2.md",
    "chars": 8071,
    "preview": "# Migration Guide: 1.x to 2.x\n\n`PyPDF2<2.0.0` ([docs](https://pypdf2.readthedocs.io/en/1.27.12/meta/history.html))\nis ve"
  },
  {
    "path": "docs/meta/project-governance.md",
    "chars": 7385,
    "preview": "# Project Governance\n\nThis document describes how the pypdf project is managed. It describes the\ndifferent actors, their"
  },
  {
    "path": "docs/meta/scope-of-pypdf.md",
    "chars": 4391,
    "preview": "# Scope of pypdf\n\nWhat features should pypdf have and which features will it never have?\n\npypdf aims at simplifying inte"
  },
  {
    "path": "docs/meta/taking-ownership.md",
    "chars": 1968,
    "preview": "# Taking Ownership of pypdf\n\npypdf is currently maintained by stefan6419846. We want to avoid that\npypdf ever goes unmai"
  },
  {
    "path": "docs/modules/Destination.rst",
    "chars": 143,
    "preview": "The Destination Class\n---------------------\n\n.. autoclass:: pypdf.generic.Destination\n    :members:\n    :undoc-members:\n"
  },
  {
    "path": "docs/modules/DocumentInformation.rst",
    "chars": 159,
    "preview": "The DocumentInformation Class\n-----------------------------\n\n.. autoclass:: pypdf.DocumentInformation\n    :members:\n    "
  },
  {
    "path": "docs/modules/Field.rst",
    "chars": 125,
    "preview": "The Field Class\n---------------\n\n.. autoclass:: pypdf.generic.Field\n    :members:\n    :undoc-members:\n    :show-inherita"
  },
  {
    "path": "docs/modules/Fit.rst",
    "chars": 119,
    "preview": "The Fit Class\n-------------\n\n.. autoclass:: pypdf.generic.Fit\n    :members:\n    :undoc-members:\n    :show-inheritance:\n"
  },
  {
    "path": "docs/modules/PageObject.rst",
    "chars": 372,
    "preview": "The PageObject Class\n--------------------\n\n.. autoclass:: pypdf._page.PageObject\n    :members:\n    :undoc-members:\n    :"
  },
  {
    "path": "docs/modules/PageRange.rst",
    "chars": 129,
    "preview": "The PageRange Class\n-------------------\n\n.. autoclass:: pypdf.PageRange\n    :members:\n    :undoc-members:\n    :show-inhe"
  },
  {
    "path": "docs/modules/PaperSize.rst",
    "chars": 813,
    "preview": "The PaperSize Class\n-------------------\n\n.. autoclass:: pypdf.PaperSize\n    :members:\n    :undoc-members:\n    :show-inhe"
  },
  {
    "path": "docs/modules/PdfDocCommon.rst",
    "chars": 360,
    "preview": "The PdfDocCommon Class\n----------------------\n\n**PdfDocCommon** is an abstract class which is inherited by :class:`~pypd"
  },
  {
    "path": "docs/modules/PdfReader.rst",
    "chars": 245,
    "preview": "The PdfReader Class\n-------------------\n\n.. autoclass:: pypdf.PdfReader\n    :members:\n    :inherited-members:\n    :undoc"
  },
  {
    "path": "docs/modules/PdfWriter.rst",
    "chars": 251,
    "preview": "The PdfWriter Class\n-------------------\n\n.. autoclass:: pypdf.PdfWriter\n    :members:\n    :inherited-members:\n    :undoc"
  },
  {
    "path": "docs/modules/RectangleObject.rst",
    "chars": 155,
    "preview": "The RectangleObject Class\n-------------------------\n\n.. autoclass:: pypdf.generic.RectangleObject\n    :members:\n    :und"
  },
  {
    "path": "docs/modules/Transformation.rst",
    "chars": 144,
    "preview": "The Transformation Class\n------------------------\n\n.. autoclass:: pypdf.Transformation\n    :members:\n    :undoc-members:"
  },
  {
    "path": "docs/modules/XmpInformation.rst",
    "chars": 149,
    "preview": "The XmpInformation Class\n-------------------------\n\n.. autoclass:: pypdf.xmp.XmpInformation\n    :members:\n    :undoc-mem"
  },
  {
    "path": "docs/modules/annotations.rst",
    "chars": 138,
    "preview": "The annotations module\n----------------------\n\n.. automodule:: pypdf.annotations\n    :members:\n    :undoc-members:\n    :"
  },
  {
    "path": "docs/modules/constants.rst",
    "chars": 660,
    "preview": "Constants\n---------\n\n.. autoclass:: pypdf.constants.AnnotationFlag\n    :members:\n    :undoc-members:\n    :show-inheritan"
  },
  {
    "path": "docs/modules/errors.rst",
    "chars": 101,
    "preview": "Errors\n------\n\n.. automodule:: pypdf.errors\n    :members:\n    :undoc-members:\n    :show-inheritance:\n"
  },
  {
    "path": "docs/modules/generic.rst",
    "chars": 753,
    "preview": "Generic PDF objects\n-------------------\n\n.. automodule:: pypdf.generic\n    :members:\n    :undoc-members:\n    :show-inher"
  },
  {
    "path": "docs/user/add-javascript.md",
    "chars": 742,
    "preview": "# Adding JavaScript to a PDF\n\nPDF readers vary in the extent they support JavaScript, with some not supporting it at all"
  },
  {
    "path": "docs/user/add-watermark.md",
    "chars": 3529,
    "preview": "# Adding a Stamp or Watermark to a PDF\n\nAdding stamps or watermarks are two common ways to manipulate PDF files.\nA stamp"
  },
  {
    "path": "docs/user/adding-pdf-annotations.md",
    "chars": 7824,
    "preview": "# Adding PDF Annotations\n\n```{note}\nBy default, some annotations might be invisible, for example polylines, as the defau"
  },
  {
    "path": "docs/user/cropping-and-transforming.md",
    "chars": 7286,
    "preview": "# Cropping and Transforming PDFs\n\n```{note}\nJust because content is no longer visible, it is not gone.\nCropping works by"
  },
  {
    "path": "docs/user/encryption-decryption.md",
    "chars": 1837,
    "preview": "# Encryption and Decryption of PDFs\n\nPDF encryption makes use of [`RC4`](https://en.wikipedia.org/wiki/RC4) and\n[`AES`]("
  },
  {
    "path": "docs/user/extract-images.md",
    "chars": 1647,
    "preview": "# Extract Images\n\n```{note}\nIn order to use the following code you need to install optional\ndependencies, see [installat"
  },
  {
    "path": "docs/user/extract-text.md",
    "chars": 15970,
    "preview": "# Extract Text from a PDF\n\nYou can extract text from a PDF:\n\n```{testsetup}\npypdf_test_setup(\"user/extract-text\", {\n    "
  },
  {
    "path": "docs/user/file-size.md",
    "chars": 4318,
    "preview": "# Reduce PDF File Size\n\nThere are multiple ways to reduce the size of a given PDF file. The easiest\none is to remove con"
  },
  {
    "path": "docs/user/forms.md",
    "chars": 6189,
    "preview": "# Interactions with PDF Forms\n\n## Reading form fields\n\n```{testsetup}\npypdf_test_setup(\"user/forms\", {\n    \"form.pdf\": \""
  },
  {
    "path": "docs/user/handle-attachments.md",
    "chars": 4042,
    "preview": "# Handle Attachments\n\nPDF documents can contain attachments, from time to time named embedded file as well.\n\n## Retrieve"
  },
  {
    "path": "docs/user/handling-outlines.md",
    "chars": 6369,
    "preview": "# Handling Outlines\n\nPDF outlines - also known as bookmarks - provide a structured navigation panel in PDF readers. `pyp"
  },
  {
    "path": "docs/user/installation.md",
    "chars": 2422,
    "preview": "# Installation\n\nThere are several ways to install pypdf. The most common option is to use pip.\n\n## pip\n\npypdf requires P"
  },
  {
    "path": "docs/user/merging-pdfs.md",
    "chars": 5734,
    "preview": "# Merging PDF files\n\n## Basic Example\n\n```{testsetup}\npypdf_test_setup(\"user/merging-pdfs\", {\n    \"example.pdf\": \"../res"
  },
  {
    "path": "docs/user/metadata.md",
    "chars": 7734,
    "preview": "# Metadata\n\nPDF files can have two types of metadata: \"Regular\" and XMP ones. They can both exist at the same time.\n\n## "
  },
  {
    "path": "docs/user/pdf-version-support.md",
    "chars": 1964,
    "preview": "# PDF Version Support\n\nPDF comes in the following versions:\n\n* 1993: 1.0\n* 1994: 1.1\n* 1996: 1.2\n* 1999: 1.3\n* 2001: 1.4"
  },
  {
    "path": "docs/user/pdfa-compliance.md",
    "chars": 4759,
    "preview": "# PDF/A Compliance\n\nPDF/A is a specialized, ISO-standardized version of the Portable Document Format\n(PDF) specifically "
  },
  {
    "path": "docs/user/post-processing-in-text-extraction.md",
    "chars": 3558,
    "preview": "# Post-Processing of Text Extraction\n\nPost-processing can recognizably improve the results of text extraction. It is,\nho"
  },
  {
    "path": "docs/user/reading-pdf-annotations.md",
    "chars": 2637,
    "preview": "# Reading PDF Annotations\n\nPDF 2.0 defines the following annotation types:\n\n* Text\n* Link\n* FreeText\n* Line\n* Square\n* C"
  },
  {
    "path": "docs/user/robustness.md",
    "chars": 1387,
    "preview": "# Robustness and strict=False\n\nPDF is [specified in various versions](https://pdfa.org/resource/pdf-specification-archiv"
  },
  {
    "path": "docs/user/security.md",
    "chars": 3794,
    "preview": "# Security\n\nWe strive to provide a library with secure defaults.\n\n## Configuration\n\n### Filters\n\n*pypdf* currently emplo"
  },
  {
    "path": "docs/user/streaming-data.md",
    "chars": 2617,
    "preview": "# Streaming Data with pypdf\n\nIn some cases, you might want to avoid saving things explicitly as a file\nto disk, e.g. whe"
  },
  {
    "path": "docs/user/suppress-warnings.md",
    "chars": 2969,
    "preview": "# Exceptions, Warnings, and Log messages\n\npypdf makes use of three mechanisms to show if something went wrong:\n\n* **Exce"
  },
  {
    "path": "docs/user/viewer-preferences.md",
    "chars": 2810,
    "preview": "# Adding Viewer Preferences\n\nIt is possible to set viewer preferences of a PDF file.\n§12.2 of the [PDF 1.7 specification"
  },
  {
    "path": "make_release.py",
    "chars": 10011,
    "preview": "\"\"\"Internal tool to update the CHANGELOG.\"\"\"\n\nimport json\nimport subprocess\nimport urllib.request\nfrom dataclasses impor"
  },
  {
    "path": "pypdf/__init__.py",
    "chars": 1283,
    "preview": "\"\"\"\npypdf is a free and open-source pure-python PDF library capable of splitting,\nmerging, cropping, and transforming th"
  },
  {
    "path": "pypdf/_cmap.py",
    "chars": 12571,
    "preview": "import binascii\nfrom binascii import Error as BinasciiError\nfrom binascii import unhexlify\nfrom math import ceil\nfrom ty"
  },
  {
    "path": "pypdf/_codecs/__init__.py",
    "chars": 1373,
    "preview": "from .adobe_glyphs import adobe_glyphs\nfrom .pdfdoc import _pdfdoc_encoding\nfrom .std import _std_encoding\nfrom .symbol "
  },
  {
    "path": "pypdf/_codecs/_codecs.py",
    "chars": 10555,
    "preview": "\"\"\"\nThis module is for codecs only.\n\nWhile the codec implementation can contain details of the PDF specification,\nthe mo"
  },
  {
    "path": "pypdf/_codecs/adobe_glyphs.py",
    "chars": 447211,
    "preview": "# https://raw.githubusercontent.com/adobe-type-tools/agl-aglfn/master/glyphlist.txt\n\n# converted manually to python\n# Ex"
  },
  {
    "path": "pypdf/_codecs/core_font_metrics.py",
    "chars": 114968,
    "preview": "# This file is based upon the 14 core AFM files provided by Adobe/Macromedia at\n# https://download.macromedia.com/pub/de"
  },
  {
    "path": "pypdf/_codecs/pdfdoc.py",
    "chars": 4269,
    "preview": "# PDFDocEncoding Character Set: Table D.2 of PDF Reference 1.7\n# C.1 Predefined encodings sorted by character name of an"
  },
  {
    "path": "pypdf/_codecs/std.py",
    "chars": 2517,
    "preview": "_std_encoding = [\n    \"\\x00\",\n    \"\\x01\",\n    \"\\x02\",\n    \"\\x03\",\n    \"\\x04\",\n    \"\\x05\",\n    \"\\x06\",\n    \"\\x07\",\n    \"\\"
  },
  {
    "path": "pypdf/_codecs/symbol.py",
    "chars": 3734,
    "preview": "# manually generated from https://www.unicode.org/Public/MAPPINGS/VENDORS/ADOBE/symbol.txt\n_symbol_encoding = [\n    \"\\u0"
  },
  {
    "path": "pypdf/_codecs/zapfding.py",
    "chars": 3742,
    "preview": "#  manually generated from https://www.unicode.org/Public/MAPPINGS/VENDORS/ADOBE/zdingbat.txt\n\n_zapfding_encoding = [\n  "
  },
  {
    "path": "pypdf/_crypt_providers/__init__.py",
    "chars": 3054,
    "preview": "# Copyright (c) 2023, exiledkingcc\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or"
  },
  {
    "path": "pypdf/_crypt_providers/_base.py",
    "chars": 1711,
    "preview": "# Copyright (c) 2023, exiledkingcc\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or"
  },
  {
    "path": "pypdf/_crypt_providers/_cryptography.py",
    "chars": 4557,
    "preview": "# Copyright (c) 2023, exiledkingcc\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or"
  },
  {
    "path": "pypdf/_crypt_providers/_fallback.py",
    "chars": 3334,
    "preview": "# Copyright (c) 2023, exiledkingcc\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or"
  },
  {
    "path": "pypdf/_crypt_providers/_pycryptodome.py",
    "chars": 3381,
    "preview": "# Copyright (c) 2023, exiledkingcc\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or"
  },
  {
    "path": "pypdf/_doc_common.py",
    "chars": 54387,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# Copyright (c) 2007, Ashish Kulkarni <kulkarni.ashish@gmail.com>\n# Copyright (c) "
  },
  {
    "path": "pypdf/_encryption.py",
    "chars": 49100,
    "preview": "# Copyright (c) 2022, exiledkingcc\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or"
  },
  {
    "path": "pypdf/_font.py",
    "chars": 14255,
    "preview": "from collections.abc import Sequence\nfrom dataclasses import dataclass, field\nfrom typing import Any, Union, cast\n\nfrom "
  },
  {
    "path": "pypdf/_page.py",
    "chars": 90186,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# Copyright (c) 2007, Ashish Kulkarni <kulkarni.ashish@gmail.com>\n#\n# All rights r"
  },
  {
    "path": "pypdf/_page_labels.py",
    "chars": 8625,
    "preview": "\"\"\"\nPage labels are shown by PDF viewers as \"the page number\".\n\nA page has a numeric index, starting at 0. Additionally,"
  },
  {
    "path": "pypdf/_protocols.py",
    "chars": 2123,
    "preview": "\"\"\"Helpers for working with PDF types.\"\"\"\n\nfrom abc import abstractmethod\nfrom pathlib import Path\nfrom typing import IO"
  },
  {
    "path": "pypdf/_reader.py",
    "chars": 57168,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# Copyright (c) 2007, Ashish Kulkarni <kulkarni.ashish@gmail.com>\n#\n# All rights r"
  },
  {
    "path": "pypdf/_text_extraction/__init__.py",
    "chars": 8515,
    "preview": "\"\"\"\nCode related to text extraction.\n\nSome parts are still in _page.py. In doubt, they will stay there.\n\"\"\"\n\nimport math"
  },
  {
    "path": "pypdf/_text_extraction/_layout_mode/__init__.py",
    "chars": 340,
    "preview": "\"\"\"Layout mode text extraction extension for pypdf\"\"\"\nfrom ..._font import Font\nfrom ._fixed_width_page import (\n    fix"
  },
  {
    "path": "pypdf/_text_extraction/_layout_mode/_fixed_width_page.py",
    "chars": 15370,
    "preview": "\"\"\"Extract PDF text preserving the layout of the source PDF\"\"\"\n\nfrom collections.abc import Iterator\nfrom itertools impo"
  },
  {
    "path": "pypdf/_text_extraction/_layout_mode/_text_state_manager.py",
    "chars": 8221,
    "preview": "\"\"\"manage the PDF transform stack during \"layout\" mode text extraction\"\"\"\n\nfrom collections import ChainMap, Counter\nfro"
  },
  {
    "path": "pypdf/_text_extraction/_layout_mode/_text_state_params.py",
    "chars": 5481,
    "preview": "\"\"\"A dataclass that captures the CTM and Text State for a tj operation\"\"\"\n\nimport math\nfrom dataclasses import dataclass"
  },
  {
    "path": "pypdf/_text_extraction/_text_extractor.py",
    "chars": 14386,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# Copyright (c) 2007, Ashish Kulkarni <kulkarni.ashish@gmail.com>\n#\n# All rights r"
  },
  {
    "path": "pypdf/_utils.py",
    "chars": 20814,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with"
  },
  {
    "path": "pypdf/_version.py",
    "chars": 22,
    "preview": "__version__ = \"6.9.1\"\n"
  },
  {
    "path": "pypdf/_writer.py",
    "chars": 131002,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# Copyright (c) 2007, Ashish Kulkarni <kulkarni.ashish@gmail.com>\n#\n# All rights r"
  },
  {
    "path": "pypdf/annotations/__init__.py",
    "chars": 990,
    "preview": "\"\"\"\nPDF specifies several annotation types which pypdf makes available here.\n\nThe names of the annotations and their att"
  },
  {
    "path": "pypdf/annotations/_base.py",
    "chars": 961,
    "preview": "from abc import ABC\n\nfrom ..constants import AnnotationFlag\nfrom ..generic import NameObject, NumberObject\nfrom ..generi"
  },
  {
    "path": "pypdf/annotations/_markup_annotations.py",
    "chars": 11862,
    "preview": "import sys\nimport uuid\nfrom abc import ABC\nfrom typing import Any, Literal, Optional, Union\n\nfrom ..constants import Ann"
  },
  {
    "path": "pypdf/annotations/_non_markup_annotations.py",
    "chars": 3649,
    "preview": "from typing import TYPE_CHECKING, Any, Optional, Union\n\nfrom ..generic._base import (\n    BooleanObject,\n    NameObject,"
  },
  {
    "path": "pypdf/constants.py",
    "chars": 23623,
    "preview": "\"\"\"Various constants, enums, and flags to aid readability.\"\"\"\n\nfrom enum import Enum, IntFlag, auto, unique\n\n\nclass StrE"
  },
  {
    "path": "pypdf/errors.py",
    "chars": 1947,
    "preview": "\"\"\"\nAll errors/exceptions pypdf raises and all of the warnings it uses.\n\nPlease note that broken PDF files might cause o"
  },
  {
    "path": "pypdf/filters.py",
    "chars": 30413,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with"
  },
  {
    "path": "pypdf/generic/__init__.py",
    "chars": 3468,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with"
  },
  {
    "path": "pypdf/generic/_appearance_stream.py",
    "chars": 26834,
    "preview": "import re\nfrom dataclasses import dataclass\nfrom enum import IntEnum\nfrom typing import Any, Optional, Union, cast\n\nfrom"
  },
  {
    "path": "pypdf/generic/_base.py",
    "chars": 32755,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with"
  },
  {
    "path": "pypdf/generic/_data_structures.py",
    "chars": 65753,
    "preview": "# Copyright (c) 2006, Mathieu Fenniak\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with"
  },
  {
    "path": "pypdf/generic/_files.py",
    "chars": 16238,
    "preview": "from __future__ import annotations\n\nimport bisect\nfrom functools import cached_property\nfrom typing import TYPE_CHECKING"
  },
  {
    "path": "pypdf/generic/_fit.py",
    "chars": 5515,
    "preview": "from typing import Any, Optional, Union\n\nfrom ._base import is_null_or_none\n\n\nclass Fit:\n    def __init__(\n        self,"
  },
  {
    "path": "pypdf/generic/_image_inline.py",
    "chars": 12787,
    "preview": "# Copyright (c) 2024, pypdf contributors\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, w"
  },
  {
    "path": "pypdf/generic/_image_xobject.py",
    "chars": 21944,
    "preview": "\"\"\"Functions to convert an image XObject to an image\"\"\"\n\nimport sys\nfrom io import BytesIO\nfrom typing import Any, Liter"
  },
  {
    "path": "pypdf/generic/_link.py",
    "chars": 5799,
    "preview": "# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or without\n# modification, are permit"
  },
  {
    "path": "pypdf/generic/_outline.py",
    "chars": 1094,
    "preview": "from typing import Union\n\nfrom .._utils import StreamType, deprecation_no_replacement\nfrom ._base import NameObject\nfrom"
  },
  {
    "path": "pypdf/generic/_rectangle.py",
    "chars": 3785,
    "preview": "from typing import Any, Union\n\nfrom ._base import FloatObject, NumberObject\nfrom ._data_structures import ArrayObject\n\n\n"
  },
  {
    "path": "pypdf/generic/_utils.py",
    "chars": 7258,
    "preview": "import codecs\nfrom typing import Union\n\nfrom .._codecs import _pdfdoc_encoding\nfrom .._utils import StreamType, logger_w"
  },
  {
    "path": "pypdf/generic/_viewerpref.py",
    "chars": 6774,
    "preview": "# Copyright (c) 2023, Pubpub-ZZ\n#\n# All rights reserved.\n#\n# Redistribution and use in source and binary forms, with or "
  },
  {
    "path": "pypdf/pagerange.py",
    "chars": 7108,
    "preview": "\"\"\"\nRepresentation and utils for ranges of PDF file pages.\n\nCopyright (c) 2014, Steve Witham <switham_github@mac-guyver."
  },
  {
    "path": "pypdf/papersizes.py",
    "chars": 1413,
    "preview": "\"\"\"Helper to get paper sizes.\"\"\"\n\nfrom typing import NamedTuple\n\n\nclass Dimensions(NamedTuple):\n    width: int\n    heigh"
  },
  {
    "path": "pypdf/py.typed",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "pypdf/types.py",
    "chars": 1915,
    "preview": "\"\"\"Helpers for working with PDF types.\"\"\"\n\nimport sys\nfrom typing import Literal, Union\n\nif sys.version_info[:2] >= (3, "
  },
  {
    "path": "pypdf/xmp.py",
    "chars": 29236,
    "preview": "\"\"\"\nAnything related to Extensible Metadata Platform (XMP) metadata.\n\nhttps://en.wikipedia.org/wiki/Extensible_Metadata_"
  },
  {
    "path": "pyproject.toml",
    "chars": 9128,
    "preview": "[build-system]\nrequires = [\"flit_core >=3.11,<4\"]\nbuild-backend = \"flit_core.buildapi\"\n\n[project]\nname = \"pypdf\"\nauthors"
  },
  {
    "path": "requirements/ci-3.11.txt",
    "chars": 1560,
    "preview": "#\n# This file is autogenerated by pip-compile with Python 3.11\n# by the following command:\n#\n#    pip-compile --output-f"
  },
  {
    "path": "requirements/ci.in",
    "chars": 168,
    "preview": "coverage\nfpdf2\nmypy\npillow\ncryptography\npytest\npytest-benchmark\npytest-socket\npytest-timeout\npytest-xdist\npytest-cov\n# r"
  },
  {
    "path": "requirements/ci.txt",
    "chars": 1450,
    "preview": "#\n# This file is autogenerated by pip-compile with Python 3.9\n# by the following command:\n#\n#    pip-compile requirement"
  },
  {
    "path": "requirements/dev.in",
    "chars": 50,
    "preview": "pillow\npip-tools\npre-commit\npytest-cov\nflit\nwheel\n"
  },
  {
    "path": "requirements/dev.txt",
    "chars": 1646,
    "preview": "#\n# This file is autogenerated by pip-compile with Python 3.9\n# by the following command:\n#\n#    pip-compile requirement"
  },
  {
    "path": "requirements/docs.in",
    "chars": 36,
    "preview": "sphinx\nsphinx_rtd_theme\nmyst_parser\n"
  },
  {
    "path": "requirements/docs.txt",
    "chars": 1505,
    "preview": "#\n# This file is autogenerated by pip-compile with Python 3.10\n# by the following command:\n#\n#    pip-compile requiremen"
  },
  {
    "path": "resources/010-pdflatex-forms.txt",
    "chars": 104,
    "preview": "Name\n\nCheck\n\nSubmit\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n                                 1"
  },
  {
    "path": "resources/AEO.1172.layout.rot180.txt",
    "chars": 1996,
    "preview": "9  1of    Page                                                                                                          "
  },
  {
    "path": "resources/AEO.1172.layout.txt",
    "chars": 1076,
    "preview": "                                                                                                            STATUS: FNL\n"
  },
  {
    "path": "resources/Claim Maker Alerts Guide_pg2.layout.txt",
    "chars": 6005,
    "preview": " Updated System Responses for Common Scenarios\n\n\n  Scenario                                 Before Change             Af"
  },
  {
    "path": "resources/Epic.Page.layout.txt",
    "chars": 1056,
    "preview": "All Postprocedure Notes\n   Last edited 10/11/23 0919 by Danny Chaung, DO\n   Date of Service 10/11/23 0918\n   Status: Sig"
  },
  {
    "path": "resources/afm_to_dataclass.py",
    "chars": 7748,
    "preview": "# ruff: noqa: T201, INP001, D100\n# Use this file to generate Font dataclasses for the 14 Adobe Core fonts.\nimport re\nimp"
  },
  {
    "path": "resources/crazyones.txt",
    "chars": 898,
    "preview": "The Crazy Ones\nOctober 14, 1998\nHeres to the crazy ones. The misfits. The rebels. The troublemakers.\nThe round pegs in th"
  },
  {
    "path": "resources/crazyones_layout_vertical_space.txt",
    "chars": 983,
    "preview": "The Crazy Ones\nOctober 14, 1998\n\n   Heres to the crazy ones. The misfits. The rebels. The troublemakers.\n       The round"
  },
  {
    "path": "resources/crazyones_layout_vertical_space_font_height_weight.txt",
    "chars": 989,
    "preview": "The Crazy Ones\nOctober 14, 1998\n\n   Heres to the crazy ones. The misfits. The rebels. The troublemakers.\n       The round"
  },
  {
    "path": "resources/jpeg.txt",
    "chars": 82804,
    "preview": "ffd8ffe000104a46494600010100000100010000ffdb0043000302020302020303030304030304050805050404050a070706080c0a0c0c0b0a0b0b0d"
  },
  {
    "path": "resources/multicolumn-lorem-ipsum.txt",
    "chars": 4404,
    "preview": "                        Two-Column Document with Lorem Ipsum\n\n                                                         Y"
  },
  {
    "path": "resources/toy.layout.txt",
    "chars": 145,
    "preview": "AWAY again1\n   AWAY again2\n\n\n    Something[cited]\n\n              Single quote operator\n              Double quote operat"
  },
  {
    "path": "tests/__init__.py",
    "chars": 4600,
    "preview": "import concurrent.futures\nimport os\nimport ssl\nimport sys\nimport urllib.request\nfrom pathlib import Path\nfrom typing imp"
  },
  {
    "path": "tests/bench.py",
    "chars": 6622,
    "preview": "\"\"\"\nBenchmark the speed of pypdf.\n\nThe results are on https://py-pdf.github.io/pypdf/dev/bench/\nPlease keep in mind that"
  },
  {
    "path": "tests/conftest.py",
    "chars": 381,
    "preview": "\"\"\"Fixtures that are available automatically for all tests.\"\"\"\n\nimport uuid\n\nimport pytest\n\n\n@pytest.fixture(scope=\"sess"
  },
  {
    "path": "tests/example_files.yaml",
    "chars": 7507,
    "preview": "- local_filename: 2201.00214.pdf\n  url: https://arxiv.org/pdf/2201.00214.pdf\n- local_filename: ASurveyofImageClassificat"
  },
  {
    "path": "tests/generic/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "tests/generic/test_base.py",
    "chars": 1521,
    "preview": "\"\"\"Test the pypdf.generic._base module.\"\"\"\nfrom io import BytesIO\n\nimport pytest\n\nfrom pypdf import PdfReader, PdfWriter"
  },
  {
    "path": "tests/generic/test_data_structures.py",
    "chars": 9423,
    "preview": "\"\"\"Test the pypdf.generic._data_structures module.\"\"\"\nimport os\nimport subprocess\nimport sys\nfrom io import BytesIO\nfrom"
  },
  {
    "path": "tests/generic/test_files.py",
    "chars": 22081,
    "preview": "\"\"\"Test the pypdf.generic._files module.\"\"\"\nimport datetime\nimport shutil\nimport subprocess\nfrom io import BytesIO\n\nimpo"
  },
  {
    "path": "tests/generic/test_image_inline.py",
    "chars": 2722,
    "preview": "\"\"\"Test the pypdf.generic._image_inline module.\"\"\"\nfrom io import BytesIO\n\nimport pytest\n\nfrom pypdf import PdfReader\nfr"
  },
  {
    "path": "tests/generic/test_image_xobject.py",
    "chars": 9312,
    "preview": "\"\"\"Test the pypdf.generic._image_xobject module.\"\"\"\nfrom io import BytesIO\n\nimport pytest\nfrom PIL import Image\n\nfrom py"
  },
  {
    "path": "tests/generic/test_link.py",
    "chars": 1634,
    "preview": "\"\"\"Test the pypdf.generic._link module.\"\"\"\nfrom io import BytesIO\n\nimport pytest\n\nfrom pypdf import PageObject, PdfReade"
  },
  {
    "path": "tests/scripts/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "tests/scripts/data/commits__version_4_0_1.json",
    "chars": 26833,
    "preview": "[\n  {\n    \"sha\": \"b7bfd0d7eddfd0865a94cc9e7027df6596242cf7\",\n    \"node_id\": \"C_kwDOAC-ZndoAKGI3YmZkMGQ3ZWRkZmQwODY1YTk0Y"
  },
  {
    "path": "tests/scripts/test_example_files.py",
    "chars": 468,
    "preview": "\"\"\"Tests related to the example files.\"\"\"\nfrom operator import itemgetter\nfrom pathlib import Path\n\nfrom tests import re"
  },
  {
    "path": "tests/scripts/test_make_release.py",
    "chars": 6351,
    "preview": "\"\"\"Test the `make_release.py` script.\"\"\"\nimport sys\nfrom pathlib import Path\nfrom unittest import mock\n\nimport pytest\n\nD"
  },
  {
    "path": "tests/test_annotations.py",
    "chars": 14538,
    "preview": "\"\"\"Test the pypdf.annotations submodule.\"\"\"\n\nfrom io import BytesIO\nfrom pathlib import Path\n\nimport pytest\n\nfrom pypdf "
  },
  {
    "path": "tests/test_appearance_stream.py",
    "chars": 3786,
    "preview": "\"\"\"Test the pypdf.generic._appearance_stream module.\"\"\"\n\nfrom pypdf.generic._appearance_stream import BaseStreamConfig, "
  },
  {
    "path": "tests/test_cmap.py",
    "chars": 13736,
    "preview": "\"\"\"Test the pypdf_cmap module.\"\"\"\nfrom io import BytesIO\n\nimport pytest\n\nfrom pypdf import PdfReader, PdfWriter\nfrom pyp"
  },
  {
    "path": "tests/test_codecs.py",
    "chars": 11495,
    "preview": "\"\"\"Test LZW-related code.\"\"\"\nfrom io import BytesIO\n\nimport pytest\n\nfrom pypdf import PdfReader\nfrom pypdf._codecs._code"
  },
  {
    "path": "tests/test_constants.py",
    "chars": 3757,
    "preview": "\"\"\"Test the pypdf.constants module.\"\"\"\nimport re\nfrom typing import Callable\n\nimport pytest\n\nfrom pypdf.constants import"
  },
  {
    "path": "tests/test_doc_common.py",
    "chars": 17715,
    "preview": "\"\"\"Test the pypdf._doc_common module.\"\"\"\nimport itertools\nimport re\nimport shutil\nimport subprocess\nfrom io import Bytes"
  },
  {
    "path": "tests/test_encryption.py",
    "chars": 15321,
    "preview": "\"\"\"Test the pypdf._encryption module.\"\"\"\nimport secrets\nfrom io import BytesIO\n\nimport pytest\n\nimport pypdf\nfrom pypdf i"
  },
  {
    "path": "tests/test_filters.py",
    "chars": 40439,
    "preview": "\"\"\"Test the pypdf.filters module.\"\"\"\nimport os\nimport string\nimport subprocess\nimport sys\nimport zlib\nfrom io import Byt"
  },
  {
    "path": "tests/test_font.py",
    "chars": 1166,
    "preview": "\"\"\"Test font-related functionality.\"\"\"\n\nfrom pypdf._font import Font\nfrom pypdf.generic import DictionaryObject, NameObj"
  },
  {
    "path": "tests/test_forms.py",
    "chars": 734,
    "preview": "\"\"\"Test form-related functionality. Separate file to keep overview.\"\"\"\n\nfrom io import BytesIO\n\nimport pytest\n\nfrom pypd"
  },
  {
    "path": "tests/test_generic.py",
    "chars": 42998,
    "preview": "\"\"\"Test the pypdf.generic module.\"\"\"\n\nimport codecs\nimport gc\nimport weakref\nfrom base64 import a85encode\nfrom copy impo"
  },
  {
    "path": "tests/test_images.py",
    "chars": 24174,
    "preview": "\"\"\"\nTests which ensure that image extraction works properly go here.\n\nTypically, tests in here should compare the extrac"
  },
  {
    "path": "tests/test_javascript.py",
    "chars": 1558,
    "preview": "\"\"\"Test topics around the usage of JavaScript in PDF documents.\"\"\"\nfrom typing import Any\n\nimport pytest\n\nfrom pypdf imp"
  },
  {
    "path": "tests/test_merger.py",
    "chars": 16027,
    "preview": "\"\"\"Test merging PDF functionality.\"\"\"\nfrom io import BytesIO\nfrom pathlib import Path\n\nimport pytest\n\nimport pypdf\nfrom "
  },
  {
    "path": "tests/test_page.py",
    "chars": 52595,
    "preview": "\"\"\"Test the pypdf._page module.\"\"\"\nimport json\nimport math\nimport os\nimport re\nimport shutil\nimport subprocess\nimport sy"
  },
  {
    "path": "tests/test_page_labels.py",
    "chars": 4764,
    "preview": "\"\"\"Test the pypdf._page_labels module.\"\"\"\nfrom io import BytesIO\n\nimport pytest\n\nfrom pypdf import PdfReader\nfrom pypdf."
  },
  {
    "path": "tests/test_pagerange.py",
    "chars": 3649,
    "preview": "\"\"\"Test the pypdf.pagerange module.\"\"\"\nimport pytest\n\nfrom pypdf.pagerange import PageRange, ParseError, parse_filename_"
  },
  {
    "path": "tests/test_papersizes.py",
    "chars": 1197,
    "preview": "\"\"\"Test the pypdf.papersizes module.\"\"\"\nimport pytest\n\nfrom pypdf import papersizes\n\n\ndef test_din_a0_paper_size():\n    "
  },
  {
    "path": "tests/test_pdfa.py",
    "chars": 1415,
    "preview": "\"\"\"Ensure that pypdf doesn't break PDF/A compliance.\"\"\"\n\nfrom io import BytesIO\nfrom pathlib import Path\nfrom typing imp"
  },
  {
    "path": "tests/test_protocols.py",
    "chars": 411,
    "preview": "\"\"\"Test the pypdf._protocols module.\"\"\"\nfrom pypdf._protocols import PdfObjectProtocol\n\n\nclass IPdfObjectProtocol(PdfObj"
  }
]

// ... and 7 more files (download for full content)