pyOpenVBA 6.3.5__tar.gz → 6.5.0__tar.gz

{pyopenvba-6.3.5 → pyopenvba-6.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyOpenVBA
-Version: 6.3.5
+Version: 6.5.0
 Summary: Read and write VBA macros and Excel Power Query in pure Python, no dependencies.
 Project-URL: Homepage, https://github.com/WilliamSmithEdward/pyOpenVBA
 Project-URL: Repository, https://github.com/WilliamSmithEdward/pyOpenVBA
@@ -37,15 +37,15 @@ Description-Content-Type: text/markdown
 
 # pyOpenVBA
 
-[![PyPI version](https://img.shields.io/pypi/v/pyOpenVBA.svg)](https://pypi.org/project/pyOpenVBA/)
-[![Python versions](https://img.shields.io/pypi/pyversions/pyOpenVBA.svg)](https://pypi.org/project/pyOpenVBA/)
-[![CI](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/ci.yml/badge.svg)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/ci.yml)
-[![Security](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/security.yml/badge.svg)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/security.yml)
-[![Malware scan](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/malware-scan.yml/badge.svg)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/malware-scan.yml)
+[![PyPI version](https://img.shields.io/pypi/v/pyOpenVBA)](https://pypi.org/project/pyOpenVBA/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pyOpenVBA)](https://pypi.org/project/pyOpenVBA/)
+[![Downloads](https://static.pepy.tech/badge/pyOpenVBA/month)](https://pepy.tech/projects/pyOpenVBA)
+[![CI](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/ci.yml)
+[![Security](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/security.yml/badge.svg?branch=main)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/security.yml)
+[![Malware scan](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/malware-scan.yml/badge.svg?branch=main)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/malware-scan.yml)
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/WilliamSmithEdward/pyOpenVBA/badge)](https://scorecard.dev/viewer/?uri=github.com/WilliamSmithEdward/pyOpenVBA)
 [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/15116/badge)](https://www.bestpractices.dev/projects/15116)
-[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/WilliamSmithEdward/pyOpenVBA/blob/main/LICENSE.md)
-[![Downloads](https://static.pepy.tech/badge/pyOpenVBA/month)](https://pepy.tech/project/pyOpenVBA)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/WilliamSmithEdward/pyOpenVBA/blob/main/LICENSE.md)
 
 **Read and write the code inside Office files, in pure Python: VBA macros
 in four hosts, and Power Query in Excel.**
@@ -985,7 +985,66 @@ Every save is verified to reopen in the host application without the
 
 ## Safety guards
 
-`save()` refuses to silently produce a broken file.
+ZIP-based VBA saves copy untouched compressed parts by default, avoiding
+recompression of the rest of the document. Existing corruption in those parts
+is preserved without checking their compressed data or CRC. Use
+`wb.save(full_rebuild=True)` (also on `WordFile` and `PowerPointFile`) to
+decompress and rewrite every retained part and detect such damage. This does
+not repair damaged parts. Unsupported packages fall back to a full rebuild;
+legacy binary formats ignore this flag.
+
+### File integrity checks and conservative repair
+
+Check a file explicitly before or after editing, independently of the fast
+save path:
+
+```python
+from pyopenvba import check_file, repair_file, FileRepairError
+
+report = check_file("book.xlsm")
+for issue in report.issues:
+    print(issue.severity, issue.code, issue.location, issue.message)
+
+if report.ok:
+    print("All supported integrity checks passed")
+elif report.complete and report.errors and all(i.repairable for i in report.errors):
+    try:
+        result = repair_file("book.xlsm", output="book.repaired.xlsm")
+        print(result.changes, result.after.ok)
+    except FileRepairError as exc:
+        print(exc.report.issues)
+```
+
+`check_file()` returns a `FileCheckReport` containing `errors`, `warnings`,
+`checked_parts`, and `complete`. `ok` requires no errors and complete coverage
+of the supported checks. ZIP parts are decompressed and CRC checked; local
+headers, data descriptors, XML, content types, and internal relationships are
+checked too. CFB directory pointers and stream sizes are checked, and supported
+VBA projects have their module sources and forms parsed. VBA is never executed.
+These checks do not prove that Office can open the document, compile its VBA,
+or verify its digital signatures.
+
+Repair initially supports **stale local ZIP CRC/size fields only**, when the
+actual payload passes central-directory verification. It preserves every
+other byte and checks the candidate before writing a new file. It refuses
+missing parts, corrupt payloads, ambiguous entries, and incomplete checks;
+`FileRepairError.report` explains the refusal. An existing output is never
+overwritten, and a healthy input can be copied without changes.
+
+The default limits are 256 MiB per uncompressed part and 1 GiB for both input
+size and the sum of declared uncompressed sizes. Raise `max_part_bytes` and
+`max_total_bytes` explicitly for trusted larger files. Invalid limits, oversized
+input, missing paths, and filesystem failures raise exceptions. A skipped part
+is reported as incomplete. ZIP64 payloads are verified, but local ZIP64 size
+metadata is currently reported as incomplete. Unknown VBA formats and Access
+coverage are also explicit warnings: Access checks its catalog and VBA, not
+every table row or allocation map. Access's existing `compact_and_repair()`
+returns a rebuilt database and remains a separate operation.
+
+Encrypted ZIP parts and compression methods other than stored/deflate are
+reported as incomplete and cannot be repaired by this API.
+
+`save()` enforces the following protection and signature gates.
 
 ### Password-protected projects
 

{pyopenvba-6.3.5 → pyopenvba-6.5.0}/README.md

@@ -1,14 +1,14 @@
 # pyOpenVBA
 
-[![PyPI version](https://img.shields.io/pypi/v/pyOpenVBA.svg)](https://pypi.org/project/pyOpenVBA/)
-[![Python versions](https://img.shields.io/pypi/pyversions/pyOpenVBA.svg)](https://pypi.org/project/pyOpenVBA/)
-[![CI](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/ci.yml/badge.svg)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/ci.yml)
-[![Security](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/security.yml/badge.svg)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/security.yml)
-[![Malware scan](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/malware-scan.yml/badge.svg)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/malware-scan.yml)
+[![PyPI version](https://img.shields.io/pypi/v/pyOpenVBA)](https://pypi.org/project/pyOpenVBA/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pyOpenVBA)](https://pypi.org/project/pyOpenVBA/)
+[![Downloads](https://static.pepy.tech/badge/pyOpenVBA/month)](https://pepy.tech/projects/pyOpenVBA)
+[![CI](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/ci.yml)
+[![Security](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/security.yml/badge.svg?branch=main)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/security.yml)
+[![Malware scan](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/malware-scan.yml/badge.svg?branch=main)](https://github.com/WilliamSmithEdward/pyOpenVBA/actions/workflows/malware-scan.yml)
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/WilliamSmithEdward/pyOpenVBA/badge)](https://scorecard.dev/viewer/?uri=github.com/WilliamSmithEdward/pyOpenVBA)
 [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/15116/badge)](https://www.bestpractices.dev/projects/15116)
-[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/WilliamSmithEdward/pyOpenVBA/blob/main/LICENSE.md)
-[![Downloads](https://static.pepy.tech/badge/pyOpenVBA/month)](https://pepy.tech/project/pyOpenVBA)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/WilliamSmithEdward/pyOpenVBA/blob/main/LICENSE.md)
 
 **Read and write the code inside Office files, in pure Python: VBA macros
 in four hosts, and Power Query in Excel.**
@@ -948,7 +948,66 @@ Every save is verified to reopen in the host application without the
 
 ## Safety guards
 
-`save()` refuses to silently produce a broken file.
+ZIP-based VBA saves copy untouched compressed parts by default, avoiding
+recompression of the rest of the document. Existing corruption in those parts
+is preserved without checking their compressed data or CRC. Use
+`wb.save(full_rebuild=True)` (also on `WordFile` and `PowerPointFile`) to
+decompress and rewrite every retained part and detect such damage. This does
+not repair damaged parts. Unsupported packages fall back to a full rebuild;
+legacy binary formats ignore this flag.
+
+### File integrity checks and conservative repair
+
+Check a file explicitly before or after editing, independently of the fast
+save path:
+
+```python
+from pyopenvba import check_file, repair_file, FileRepairError
+
+report = check_file("book.xlsm")
+for issue in report.issues:
+    print(issue.severity, issue.code, issue.location, issue.message)
+
+if report.ok:
+    print("All supported integrity checks passed")
+elif report.complete and report.errors and all(i.repairable for i in report.errors):
+    try:
+        result = repair_file("book.xlsm", output="book.repaired.xlsm")
+        print(result.changes, result.after.ok)
+    except FileRepairError as exc:
+        print(exc.report.issues)
+```
+
+`check_file()` returns a `FileCheckReport` containing `errors`, `warnings`,
+`checked_parts`, and `complete`. `ok` requires no errors and complete coverage
+of the supported checks. ZIP parts are decompressed and CRC checked; local
+headers, data descriptors, XML, content types, and internal relationships are
+checked too. CFB directory pointers and stream sizes are checked, and supported
+VBA projects have their module sources and forms parsed. VBA is never executed.
+These checks do not prove that Office can open the document, compile its VBA,
+or verify its digital signatures.
+
+Repair initially supports **stale local ZIP CRC/size fields only**, when the
+actual payload passes central-directory verification. It preserves every
+other byte and checks the candidate before writing a new file. It refuses
+missing parts, corrupt payloads, ambiguous entries, and incomplete checks;
+`FileRepairError.report` explains the refusal. An existing output is never
+overwritten, and a healthy input can be copied without changes.
+
+The default limits are 256 MiB per uncompressed part and 1 GiB for both input
+size and the sum of declared uncompressed sizes. Raise `max_part_bytes` and
+`max_total_bytes` explicitly for trusted larger files. Invalid limits, oversized
+input, missing paths, and filesystem failures raise exceptions. A skipped part
+is reported as incomplete. ZIP64 payloads are verified, but local ZIP64 size
+metadata is currently reported as incomplete. Unknown VBA formats and Access
+coverage are also explicit warnings: Access checks its catalog and VBA, not
+every table row or allocation map. Access's existing `compact_and_repair()`
+returns a rebuilt database and remains a separate operation.
+
+Encrypted ZIP parts and compression methods other than stored/deflate are
+reported as incomplete and cannot be repaired by this API.
+
+`save()` enforces the following protection and signature gates.
 
 ### Password-protected projects
 

{pyopenvba-6.3.5 → pyopenvba-6.5.0}/docs/architecture.md

@@ -313,6 +313,13 @@ For the ZIP case, the VBA project is at the fixed path
 `xl/vbaProject.bin`. On save, exactly that entry is replaced while
 every other ZIP entry is preserved byte-for-byte including its
 compression method, external attributes, create system, and timestamp.
+By default, unchanged parts keep their compressed bytes (`_package_copy.py`),
+avoiding decompression and recompression. They are not checked for damaged
+compressed data or CRC mismatches. `save(full_rebuild=True)` uses the previous
+`zipfile` writer, which decompresses and rewrites every retained part and
+refuses damaged ones. ZIP64 and other unsupported packages fall back to that
+writer automatically. Copying still takes time proportional to compressed
+package size; it avoids work proportional to the expanded content.
 
 For `.xls` and `.doc`, the entire file *is* the CFB; `cfb.to_bytes()`
 is written straight to the output path.

{pyopenvba-6.3.5 → pyopenvba-6.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyOpenVBA"
-version = "6.3.5"
+version = "6.5.0"
 description = "Read and write VBA macros and Excel Power Query in pure Python, no dependencies."
 readme = "README.md"
 license = { text = "MIT" }

{pyopenvba-6.3.5 → pyopenvba-6.5.0}/src/pyopenvba/__init__.py

@@ -81,6 +81,9 @@ from pyopenvba.exceptions import (
     VBAProjectError,
 )
 from pyopenvba.forms import FormControl, Size, VBAForm
+from pyopenvba.integrity import (
+    FileCheckReport, FileIssue, FileRepairError, FileRepairResult, check_file, repair_file,
+)
 from pyopenvba.powerpoint import PowerPointFile
 from pyopenvba.powerquery import PowerQuery, PowerQueryWorkbook, QueryGroup, RefreshSettings
 from pyopenvba.powerquery import pull_queries as _pull_queries
@@ -228,6 +231,12 @@ def push_access(
 
 
 __all__ = [
+    "FileCheckReport",
+    "FileIssue",
+    "FileRepairError",
+    "FileRepairResult",
+    "check_file",
+    "repair_file",
     "AccessDatabase",
     "AccessReader",
     "CFBError",
@@ -293,4 +302,4 @@ def push_power_query(
     """
     return _push_queries(src_dir, workbook, out=out, encoding=encoding, remove_missing=remove_missing)
 
-__version__ = "6.3.5"
+__version__ = "6.5.0"

{pyopenvba-6.3.5 → pyopenvba-6.5.0}/src/pyopenvba/_host.py

@@ -20,6 +20,7 @@ from pathlib import Path
 from typing import ClassVar, TypeVar
 
 from pyopenvba._new_project import with_project
+from pyopenvba._package_copy import copy_package
 from pyopenvba._package_signature import signature_parts, without_signature
 from pyopenvba._references import ReferenceManager, module_offset, reference_spans
 from pyopenvba.cfb import CFB
@@ -108,6 +109,12 @@ class VBAHostFile(ReferenceManager):
         # Set by add_vba_project: the project is not in the package yet, and these are its document modules.
         self._project_added = False
         self._document_names: set[str] = set()
+        # Package signature edits survive repeated saves and failed writes;
+        # the original ZIP remains the source of unchanged parts.
+        self._signature_edits: dict[str, bytes | None] = {}
+        # Edits already applied to the in-memory CFB are still mutations
+        # until a write succeeds, even if their dirty flags were consumed.
+        self._pending_mutation = False
         self._open()
 
     # ------------------------------------------------------------------
@@ -251,7 +258,7 @@ class VBAHostFile(ReferenceManager):
         if not self._has_project:
             return SignatureInfo()
         info = detect_signature(self._get_cfb())
-        if self._zip is not None:
+        if self._zip is not None and not self._signature_edits:
             parts = signature_parts(self._zip.namelist(), self._zip.read, self._vba_entry)
             info.kinds += [kind for kind in dict.fromkeys(parts.values()) if kind not in info.kinds]
             info.parts = list(parts)
@@ -501,6 +508,7 @@ class VBAHostFile(ReferenceManager):
         *,
         allow_protected: bool = False,
         allow_invalidate_signature: bool = False,
+        full_rebuild: bool = False,
     ) -> None:
         """
         Save the file, applying any pending module edits.
@@ -510,7 +518,14 @@ class VBAHostFile(ReferenceManager):
         Only the ``vbaProject.bin`` entry is rewritten; every other ZIP
         entry is preserved byte-for-byte along with its compression
         method and metadata so the file's non-VBA structure remains
-        intact.  Legacy raw-CFB formats write the CFB bytes directly.
+        intact. By default, unchanged parts keep their compressed bytes;
+        they are not decompressed or checked for corruption. Set
+        ``full_rebuild=True`` to decompress and rewrite every retained
+        part, checking its compressed data and CRC in the process. This
+        detects damage; it does not repair it. Packages the copying writer
+        cannot handle safely fall back to a full rebuild automatically.
+        Legacy raw-CFB formats write the CFB bytes directly and ignore
+        ``full_rebuild``.
 
         Safety gates:
 
@@ -533,8 +548,8 @@ class VBAHostFile(ReferenceManager):
           to a UserForm's design counts: adding or removing a control
           changes the form class's members.
 
-        A file with no VBA project can hold no edit, since every write
-        refuses, so it is written out as it was read.
+        A file with no VBA project is copied as read unless
+        ``full_rebuild=True`` requests rebuilding its ZIP container.
 
         Templates and add-ins that share a supported layout (``.xltm``,
         ``.xlt``, ``.xla``, ``.dot``, ``.ppsm``, ``.ppam``) open read only:
@@ -545,7 +560,9 @@ class VBAHostFile(ReferenceManager):
                 f"Saving a {self._suffix} file is not supported; it opens read only."
             )
         if not self._has_project:
-            if dest is not None:
+            if full_rebuild and self._suffix in self._zip_formats:
+                self._write_container(dest, None, {}, full_rebuild=True)
+            elif dest is not None:
                 Path(dest).write_bytes(self._container_raw)
             return
         cfb = self._get_cfb()
@@ -561,9 +578,11 @@ class VBAHostFile(ReferenceManager):
         for form in self._forms or ():
             # Not any(...): that short-circuits, and every form has to be
             # written, not just the first dirty one.
-            forms_dirty |= form.write_back(cfb)
+            changed = form.write_back(cfb)
+            forms_dirty |= changed
+            self._pending_mutation |= changed
         # What the package's other parts need: None drops a part.
-        package_edits: dict[str, bytes | None] = {}
+        package_edits = dict(self._signature_edits)
 
         if self._project is not None:
             project = self._project
@@ -575,7 +594,8 @@ class VBAHostFile(ReferenceManager):
             delete_names = set(project.pending_deletes)
             has_source_edits = any(m.dirty for m in project.modules)
             mutating = bool(
-                rename_map
+                self._pending_mutation
+                or rename_map
                 or add_names
                 or delete_names
                 or has_source_edits
@@ -598,6 +618,8 @@ class VBAHostFile(ReferenceManager):
                     f"the {self._host_noun} inconsistent)."
                 )
 
+            self._pending_mutation |= mutating
+
             # Safety gate 2: any change invalidates a present digital
             # signature.  Drop it and warn.
             if mutating:
@@ -617,7 +639,8 @@ class VBAHostFile(ReferenceManager):
         except KeyError:
             pass
         new_cfb_bytes = cfb.to_bytes()
-        self._write_container(dest, new_cfb_bytes, package_edits)
+        self._write_container(dest, new_cfb_bytes, package_edits, full_rebuild=full_rebuild)
+        self._pending_mutation = False
 
     def _apply_project(self, cfb: CFB, project: VBAProject, *, mutating: bool) -> None:
         """Write ``project``'s pending renames, adds, deletes and edits into ``cfb``."""
@@ -744,12 +767,13 @@ class VBAHostFile(ReferenceManager):
         if mutating:
             invalidate_vba_project_cache(cfb)
 
-    def _write_container(self, dest: str | Path | None, new_cfb_bytes: bytes,
-                         package_edits: dict[str, bytes | None]) -> None:
+    def _write_container(self, dest: str | Path | None, new_cfb_bytes: bytes | None,
+                         package_edits: dict[str, bytes | None], *, full_rebuild: bool = False) -> None:
         """Write the file with ``new_cfb_bytes`` as its project and ``package_edits`` applied."""
         out_path = Path(dest) if dest is not None else self._path
 
         if self._suffix in self._cfb_formats:
+            assert new_cfb_bytes is not None
             out_path.write_bytes(self._container_bytes(new_cfb_bytes))
             return
 
@@ -765,12 +789,24 @@ class VBAHostFile(ReferenceManager):
             package_edits.update(self._project_edits())
             if self._writes_project(self._project):
                 package_edits.update(with_project(self._zip.namelist(), self._zip.read, self._main_part))
+                assert new_cfb_bytes is not None
                 added[self._vba_entry] = new_cfb_bytes
 
+        # Avoid inflating and recompressing untouched parts. Unsupported
+        # packages and an explicit full rebuild retain the zipfile path.
+        if not full_rebuild:
+            edits = dict(package_edits)
+            if new_cfb_bytes is not None:
+                edits[self._vba_entry] = new_cfb_bytes
+            packed = copy_package(self._container_raw, self._zip.infolist(), edits, added)
+            if packed is not None:
+                out_path.write_bytes(packed)
+                return
+
         buf = io.BytesIO()
         with zipfile.ZipFile(buf, "w") as out_zip:
             for info in self._zip.infolist():
-                if info.filename == self._vba_entry:
+                if info.filename == self._vba_entry and new_cfb_bytes is not None:
                     out_info = zipfile.ZipInfo(
                         filename=info.filename,
                         date_time=info.date_time,
@@ -812,6 +848,8 @@ class VBAHostFile(ReferenceManager):
         zip-based file keeps beside it come back as the package's edits,
         None for each part that goes (see :mod:`pyopenvba._package_signature`).
         """
+        if self._signature_edits:
+            return dict(self._signature_edits)
         found = detect_signature(cfb)
         if found.present:
             for sig_stream in (
@@ -834,6 +872,7 @@ class VBAHostFile(ReferenceManager):
             kinds += [kind for kind in signature_parts(names, self._zip.read, self._vba_entry).values()
                       if kind not in kinds]
             edits = without_signature(names, self._zip.read, self._vba_entry)
+        self._signature_edits.update(edits)
         if kinds and not allow_invalidate_signature:
             warnings.warn(
                 f"Dropped the stale VBA digital signature ({', '.join(kinds)}) "

pyopenvba-6.5.0/src/pyopenvba/_package_copy.py

@@ -0,0 +1,172 @@
+"""Write a zip-based Office file with a few parts changed and the rest as they were stored.
+
+Saving a VBA project changes one part, ``vbaProject.bin``, and at most a
+handful of small parts beside it. Reading and recompressing everything
+else costs time proportional to the expanded content. Copying unchanged
+compressed bytes avoids that work, using the same container writer as
+Power Query and the document surfaces. It still costs time and memory
+proportional to the compressed package size.
+A changed part is deflated by zlib at its default level, as ``zipfile``
+deflates it, so it is stored as the same bytes as before this module
+existed.
+
+:func:`copy_package` answers None for a package it would not carry over
+faithfully, and the caller then writes it with ``zipfile`` as it always
+has.  That covers ZIP64, a part compressed some other way than deflate
+that has to be written anew, an encrypted part, a part name that is not
+UTF-8, an unknown compression method, unsupported patched-data or
+strong-encryption flags, and a package naming one part twice. It also
+covers a package whose two directories disagree -- a part's own header naming it
+differently, giving it other sizes in a ZIP64 record, or placing it over
+another part or the central directory -- which ``zipfile`` refuses,
+and so still does.
+"""
+
+from __future__ import annotations
+
+import struct
+import zipfile
+import zlib
+from collections.abc import Mapping, Sequence
+from dataclasses import replace
+
+from pyopenvba.exceptions import PowerQueryError
+from pyopenvba.powerquery._opc import Entry, OpcFile
+
+_STORED = 0
+_DEFLATED = 8
+#: General purpose bit 0: the part is encrypted.
+_ENCRYPTED = 0x0001
+#: Patched data and strong encryption are refused by zipfile when reading.
+_UNSUPPORTED_FLAGS = 0x0060
+_UTF8 = 0x0800
+#: General purpose bit 3: the sizes follow the part's bytes instead of standing in its header.
+_DESCRIPTOR = 0x0008
+#: The date ``zipfile`` gives a part with none, 1980-01-01, as [APPNOTE] 4.4.6 packs one.
+_NO_DATE = 0x0021
+#: A size or offset of this much is held in a ZIP64 record instead.
+_ZIP64 = 0xFFFFFFFF
+#: The extra field record that holds one.
+_ZIP64_RECORD = 0x0001
+
+
+def _has_zip64(extra: bytes) -> bool:
+    """Whether an extra field holds a ZIP64 record, or cannot be read to say."""
+    at = 0
+    while at < len(extra):
+        if at + 4 > len(extra):
+            return True
+        kind, size = struct.unpack_from("<HH", extra, at)
+        if kind == _ZIP64_RECORD:
+            return True
+        at += 4 + size
+    return False
+
+
+def _pack(data: bytes, method: int) -> bytes | None:
+    """``data`` as a part stored by ``method`` holds it; None for a method not written here."""
+    if method == _STORED:
+        return data
+    if method == _DEFLATED:
+        deflater = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -15)
+        return deflater.compress(data) + deflater.flush()
+    return None
+
+
+def copy_package(
+    raw: bytes,
+    infos: Sequence[zipfile.ZipInfo],
+    edits: Mapping[str, bytes | None],
+    added: Mapping[str, bytes],
+) -> bytes | None:
+    """The package ``raw`` with ``edits`` applied and ``added`` appended, every other part as it was stored.
+
+    ``infos`` are the package's entries as ``zipfile`` read them, which
+    is what the edits are named by.  ``edits`` gives a part its new
+    bytes, or None to leave it out; a part is kept in its place, under
+    its own compression method, dates and attributes.  ``added`` are
+    parts the package does not have yet, deflated and put last.
+
+    None means the package is one this does not write; see the module's
+    docstring.
+    """
+    try:
+        package = OpcFile.parse(raw)
+        central_start = struct.unpack_from("<I", raw, raw.rfind(b"PK\x05\x06") + 16)[0]
+    except (PowerQueryError, UnicodeDecodeError, struct.error):
+        return None
+    if len(package.entries) != len(infos) or len({info.filename for info in infos}) != len(infos):
+        return None
+
+    entries: list[Entry] = []
+    # Where the last part's bytes ended: each part has to start past the one before it.
+    end = 0
+    for entry, info in zip(package.entries, infos, strict=True):
+        # The two readers have to agree on what the part is, or an edit could land on the wrong one.
+        if (
+            entry.name != info.filename
+            or len(entry.body) != info.compress_size
+            or entry.uncompressed_size != info.file_size
+            or entry.crc != info.CRC
+            or entry.method not in (zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED, zipfile.ZIP_BZIP2, zipfile.ZIP_LZMA)
+            or entry.flags & (_ENCRYPTED | _UNSUPPORTED_FLAGS)
+            or info.compress_size >= _ZIP64
+            or info.file_size >= _ZIP64
+            or _has_zip64(entry.local_extra)
+            or _has_zip64(entry.central_extra)
+        ):
+            return None
+        # So do the part's own header and the directory: on its name, and on parts not lying over each other.
+        name = entry.name.encode("utf-8")
+        named = info.header_offset + 30
+        local_name_length, local_extra_length = struct.unpack_from("<HH", raw, info.header_offset + 26)
+        if (
+            local_name_length != len(name)
+            or local_extra_length != len(entry.local_extra)
+            or info.header_offset < end
+            or raw[named : named + local_name_length + local_extra_length] != name + entry.local_extra
+        ):
+            return None
+        local_flags = struct.unpack_from("<H", raw, info.header_offset + 6)[0]
+        if (local_flags ^ entry.flags) & _UTF8:
+            return None
+        end = named + local_name_length + local_extra_length + len(entry.body)
+        if end > central_start:
+            return None
+        # The sizes are written in the header, so nothing follows the part's bytes to say them again.
+        flags = entry.flags & ~_DESCRIPTOR
+        if entry.name in edits:
+            data = edits[entry.name]
+            if data is None:
+                continue
+            body = _pack(data, entry.method)
+            if body is None:
+                return None
+            entry = replace(
+                entry, body=body, flags=flags, crc=zlib.crc32(data) & 0xFFFFFFFF, uncompressed_size=len(data)
+            )
+        elif flags != entry.flags:
+            entry = replace(entry, flags=flags)
+        entries.append(entry)
+
+    for name, data in added.items():
+        body = _pack(data, _DEFLATED)
+        assert body is not None
+        entries.append(
+            Entry(
+                name=name,
+                body=body,
+                method=_DEFLATED,
+                flags=0,
+                dos_time=0,
+                dos_date=_NO_DATE,
+                crc=zlib.crc32(data) & 0xFFFFFFFF,
+                uncompressed_size=len(data),
+            )
+        )
+
+    try:
+        return OpcFile(entries=entries).serialize()
+    except struct.error:
+        # Past what a ZIP holds without ZIP64: more than 65535 parts, or 4 GB.
+        return None