pyOpenVBA 6.3.4__tar.gz → 6.4.0__tar.gz

{pyopenvba-6.3.4 → pyopenvba-6.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyOpenVBA
-Version: 6.3.4
+Version: 6.4.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,14 +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)
-[![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)
+[![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)](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.**
@@ -54,9 +55,9 @@ Works on Windows, macOS and Linux. Python 3.10 or newer.
 
 VBA, four hosts and one API:
 
-* Excel (`.xlsm`, `.xlsb`, `.xlam`, `.xls`)
-* Word (`.docm`, `.dotm`, `.doc`)
-* PowerPoint (`.pptm`, `.potm`, `.ppt`)
+* Excel (`.xlsm`, `.xlsb`, `.xlam`, `.xls`; `.xltm`, `.xlt`, `.xla` read only)
+* Word (`.docm`, `.dotm`, `.doc`; `.dot` read only)
+* PowerPoint (`.pptm`, `.potm`, `.ppt`; `.ppsm`, `.ppam` read only)
 * Access (`.accdb`, `.mdb`)
 
 Power Query, in any Excel package:
@@ -886,6 +887,9 @@ implemented, what is not, and how it was measured is in
 | `.xlsb`   | Binary workbook              | yes |     yes     |    yes     |
 | `.xlam`   | Macro-enabled add-in         | yes |     yes     |    yes     |
 | `.xls`    | Legacy (Excel 97-2003)       | yes |      -      |    no      |
+| `.xltm`   | Macro-enabled template       | read |    yes     |    no      |
+| `.xlt`    | Legacy template              | read |     -      |    no      |
+| `.xla`    | Legacy add-in                | read |     -      |    no      |
 
 A `.xlsx` file has no VBA project by design, and Power Query lives
 outside the project, so it is read and written in every package above.
@@ -897,6 +901,7 @@ outside the project, so it is read and written in every package above.
 | `.docm`   | Macro-enabled document       |  yes |  yes  |    yes     |
 | `.dotm`   | Macro-enabled template       |  yes |  yes  |    no      |
 | `.doc`    | Legacy (Word 97-2003)        |  yes |  yes  |    no      |
+| `.dot`    | Legacy template              |  yes |   no  |    no      |
 
 ### PowerPoint
 
@@ -904,6 +909,8 @@ outside the project, so it is read and written in every package above.
 |-----------|------------------------------|:----:|:-----:|:----------:|
 | `.pptm`   | Macro-enabled presentation   |  yes |  yes  |    yes     |
 | `.potm`   | Macro-enabled template       |  yes |  yes  |    no      |
+| `.ppsm`   | Macro-enabled show           |  yes |   no  |    no      |
+| `.ppam`   | Macro-enabled add-in         |  yes |   no  |    no      |
 | `.ppt`    | Legacy (PowerPoint 97-2003)  |  yes |  yes  |    no      |
 
 ### Files with no VBA project
@@ -978,7 +985,15 @@ 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.
+
+`save()` enforces the following protection and signature gates.
 
 ### Password-protected projects
 

{pyopenvba-6.3.4 → pyopenvba-6.4.0}/README.md

@@ -1,13 +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)
-[![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)
+[![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)](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.**
@@ -17,9 +18,9 @@ Works on Windows, macOS and Linux. Python 3.10 or newer.
 
 VBA, four hosts and one API:
 
-* Excel (`.xlsm`, `.xlsb`, `.xlam`, `.xls`)
-* Word (`.docm`, `.dotm`, `.doc`)
-* PowerPoint (`.pptm`, `.potm`, `.ppt`)
+* Excel (`.xlsm`, `.xlsb`, `.xlam`, `.xls`; `.xltm`, `.xlt`, `.xla` read only)
+* Word (`.docm`, `.dotm`, `.doc`; `.dot` read only)
+* PowerPoint (`.pptm`, `.potm`, `.ppt`; `.ppsm`, `.ppam` read only)
 * Access (`.accdb`, `.mdb`)
 
 Power Query, in any Excel package:
@@ -849,6 +850,9 @@ implemented, what is not, and how it was measured is in
 | `.xlsb`   | Binary workbook              | yes |     yes     |    yes     |
 | `.xlam`   | Macro-enabled add-in         | yes |     yes     |    yes     |
 | `.xls`    | Legacy (Excel 97-2003)       | yes |      -      |    no      |
+| `.xltm`   | Macro-enabled template       | read |    yes     |    no      |
+| `.xlt`    | Legacy template              | read |     -      |    no      |
+| `.xla`    | Legacy add-in                | read |     -      |    no      |
 
 A `.xlsx` file has no VBA project by design, and Power Query lives
 outside the project, so it is read and written in every package above.
@@ -860,6 +864,7 @@ outside the project, so it is read and written in every package above.
 | `.docm`   | Macro-enabled document       |  yes |  yes  |    yes     |
 | `.dotm`   | Macro-enabled template       |  yes |  yes  |    no      |
 | `.doc`    | Legacy (Word 97-2003)        |  yes |  yes  |    no      |
+| `.dot`    | Legacy template              |  yes |   no  |    no      |
 
 ### PowerPoint
 
@@ -867,6 +872,8 @@ outside the project, so it is read and written in every package above.
 |-----------|------------------------------|:----:|:-----:|:----------:|
 | `.pptm`   | Macro-enabled presentation   |  yes |  yes  |    yes     |
 | `.potm`   | Macro-enabled template       |  yes |  yes  |    no      |
+| `.ppsm`   | Macro-enabled show           |  yes |   no  |    no      |
+| `.ppam`   | Macro-enabled add-in         |  yes |   no  |    no      |
 | `.ppt`    | Legacy (PowerPoint 97-2003)  |  yes |  yes  |    no      |
 
 ### Files with no VBA project
@@ -941,7 +948,15 @@ 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.
+
+`save()` enforces the following protection and signature gates.
 
 ### Password-protected projects
 

{pyopenvba-6.3.4 → pyopenvba-6.4.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.4 → pyopenvba-6.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyOpenVBA"
-version = "6.3.4"
+version = "6.4.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.4 → pyopenvba-6.4.0}/src/pyopenvba/__init__.py

@@ -293,4 +293,4 @@ def push_power_query(
     """
     return _push_queries(src_dir, workbook, out=out, encoding=encoding, remove_missing=remove_missing)
 
-__version__ = "6.3.4"
+__version__ = "6.4.0"

{pyopenvba-6.3.4 → pyopenvba-6.4.0}/src/pyopenvba/__main__.py

@@ -179,12 +179,18 @@ _HOST_BY_SUFFIX: dict[str, type] = {
     ".xlsm": ExcelFile,
     ".xlsb": ExcelFile,
     ".xlam": ExcelFile,
+    ".xltm": ExcelFile,
     ".xls": ExcelFile,
+    ".xlt": ExcelFile,
+    ".xla": ExcelFile,
     ".docm": WordFile,
     ".dotm": WordFile,
     ".doc": WordFile,
+    ".dot": WordFile,
     ".pptm": PowerPointFile,
     ".potm": PowerPointFile,
+    ".ppsm": PowerPointFile,
+    ".ppam": PowerPointFile,
     ".ppt": PowerPointFile,
 }
 

{pyopenvba-6.3.4 → pyopenvba-6.4.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
@@ -91,6 +92,8 @@ class VBAHostFile(ReferenceManager):
     _project_storage: ClassVar[str | None]
     #: The formats add_vba_project gives a project to, each measured against its application.
     _project_formats: ClassVar[frozenset[str]] = frozenset()
+    #: Formats that open and read but do not save: a writer for them has not been measured.
+    _read_only_formats: ClassVar[frozenset[str]] = frozenset()
     #: The package part a zip-based file's project is related from.
     _main_part: ClassVar[str] = ""
 
@@ -106,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()
 
     # ------------------------------------------------------------------
@@ -249,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)
@@ -499,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.
@@ -508,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:
 
@@ -531,11 +548,21 @@ 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:
+        saving one raises :class:`~pyopenvba.exceptions.UnsupportedFormatError`.
         """
+        if self._suffix in self._read_only_formats:
+            raise UnsupportedFormatError(
+                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()
@@ -551,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
@@ -565,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
@@ -588,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:
@@ -607,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``."""
@@ -734,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
 
@@ -755,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,
@@ -802,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 (
@@ -824,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.4.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

{pyopenvba-6.3.4 → pyopenvba-6.4.0}/src/pyopenvba/access/_pages.py

@@ -409,6 +409,8 @@ def row_bytes(
     target with ``overflow_target=True``, where the 0x8000 bit marks the
     moved row rather than a deletion."""
     slots = row_slots(page)
+    if not 0 <= slot < len(slots):
+        raise AccessError(f"slot {slot} out of range (0..{len(slots) - 1})")
     entry = slots[slot]
     if entry & ROW_DELETED and not overflow_target:
         return None

{pyopenvba-6.3.4 → pyopenvba-6.4.0}/src/pyopenvba/access/_rows.py

@@ -184,9 +184,13 @@ def encode_text(text: str) -> bytes:
 
 def decode_datetime(raw: bytes) -> _dt.datetime:
     value = struct.unpack("<d", raw)[0]
-    days = int(value)
-    fraction = abs(value - days)
-    return EPOCH + _dt.timedelta(days=days) + _dt.timedelta(days=fraction)
+    try:
+        days = int(value)
+        fraction = abs(value - days)
+        return EPOCH + _dt.timedelta(days=days) + _dt.timedelta(days=fraction)
+    except (OverflowError, ValueError):
+        # Out of the year 1 to 9999, or not a number: a damaged value.
+        raise AccessError(f"date value {value!r} is outside the range a date can hold") from None
 
 
 def encode_datetime(value: _dt.datetime) -> bytes:
@@ -455,11 +459,23 @@ def encode_row(
     return bytes(row)
 
 
+#: The bytes a fixed-size type's value takes; any other length is a damaged row.
+_SCALAR_SIZES = {
+    TYPE_BYTE: 1, TYPE_INT: 2, TYPE_LONG: 4, TYPE_MONEY: 8, TYPE_FLOAT: 4, TYPE_DOUBLE: 8,
+    TYPE_DATETIME: 8, TYPE_GUID: 16, TYPE_COMPLEX: 4, TYPE_BIGINT: 8,
+}
+
+
 def decode_scalar(column: ColumnDef, raw: bytes) -> object:
     """Decode a non-long-value column.  ``raw`` is the present value."""
     code = column.type_code
     if code == TYPE_BOOLEAN:
         return True
+    size = _SCALAR_SIZES.get(code, 0)
+    if size and len(raw) != size:
+        raise AccessError(
+            f"column {column.name!r} holds {len(raw)} bytes where its type takes {size}; the row is damaged"
+        )
     if code == TYPE_BYTE:
         return raw[0]
     if code == TYPE_INT:

{pyopenvba-6.3.4 → pyopenvba-6.4.0}/src/pyopenvba/access/_tdef.py

@@ -333,10 +333,14 @@ def read_definition_bytes(store: PageStore, page: int) -> tuple[bytes, list[int]
 
 def _read_name(buf: bytes, pos: int) -> tuple[str, int]:
     """A name is prefixed by its length as a word, and stored as UTF-16."""
+    if pos + 2 > len(buf):
+        raise AccessError("name runs past the end of the definition")
     length = struct.unpack_from("<H", buf, pos)[0]
     raw = buf[pos + 2 : pos + 2 + length]
     if len(raw) != length:
         raise AccessError("name runs past the end of the definition")
+    if length % 2:
+        raise AccessError(f"name is {length} bytes, an odd length for UTF-16")
     return raw.decode("utf-16-le"), pos + 2 + length
 
 
@@ -463,6 +467,10 @@ def parse_table_definition(store: PageStore, page: int) -> TableDefinition:
         pos += 2
         if number == INDEX_COLUMN_UNUSED:
             break
+        if pos + 8 > len(buf):
+            raise AccessError(
+                f"table definition at page {page} ends inside its usage-map block"
+            )
         column_usage_maps[number] = (u32(pos), u32(pos + 4))
         pos += 8