pyOpenVBA 5.1.3__tar.gz → 5.2.1__tar.gz

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pyOpenVBA
-Version: 5.1.3
+Version: 5.2.1
 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
@@ -29,6 +29,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Provides-Extra: dev
 Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: openpyxl>=3.1; extra == 'dev'
 Requires-Dist: pyright>=1.1.350; extra == 'dev'
 Requires-Dist: pytest>=8; extra == 'dev'
 Requires-Dist: twine>=5; extra == 'dev'
@@ -55,7 +56,7 @@ VBA, four hosts and one API:
 * PowerPoint (`.pptm`, `.potm`, `.ppt`)
 * Access (`.accdb`, `.mdb`)
 
-Power Query, in any Excel package (`.xlsx` included):
+Power Query, in any Excel package:
 
 ```python
 from pyopenvba import PowerQueryWorkbook
@@ -385,10 +386,15 @@ with AccessDatabase("app.accdb") as db:
 
     report = db.add_report("Monthly")
     report.add_control("Label", "Banner", section="PageHeaderSection", caption="Header band")
+    db.rename_form("Draft", "Invoice")
     db.delete_form("Old")
     db.save()
 ```
 
+Renaming and deleting reach the code behind a design as well as the
+design itself. A form's module is bound to it by name, so `Form_Draft`
+becomes `Form_Invoice` and a deleted form takes its module with it.
+
 [examples/access_form_demo.py](https://github.com/WilliamSmithEdward/pyOpenVBA/blob/main/examples/access_form_demo.py)
 builds a working order calculator this way: a form whose buttons call a
 standard module and keep their running total in a class module, laid out

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/README.md

@@ -19,7 +19,7 @@ VBA, four hosts and one API:
 * PowerPoint (`.pptm`, `.potm`, `.ppt`)
 * Access (`.accdb`, `.mdb`)
 
-Power Query, in any Excel package (`.xlsx` included):
+Power Query, in any Excel package:
 
 ```python
 from pyopenvba import PowerQueryWorkbook
@@ -349,10 +349,15 @@ with AccessDatabase("app.accdb") as db:
 
     report = db.add_report("Monthly")
     report.add_control("Label", "Banner", section="PageHeaderSection", caption="Header band")
+    db.rename_form("Draft", "Invoice")
     db.delete_form("Old")
     db.save()
 ```
 
+Renaming and deleting reach the code behind a design as well as the
+design itself. A form's module is bound to it by name, so `Form_Draft`
+becomes `Form_Invoice` and a deleted form takes its module with it.
+
 [examples/access_form_demo.py](https://github.com/WilliamSmithEdward/pyOpenVBA/blob/main/examples/access_form_demo.py)
 builds a working order calculator this way: a form whose buttons call a
 standard module and keep their running total in a class module, laid out

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/docs/power_query.md

@@ -277,6 +277,47 @@ this file exists because nothing here is written on a guess.
 
 ---
 
+## Workbooks another tool wrote
+
+Excel is not the only writer of `.xlsx`, and the parts it produces are
+one legal spelling among several. Three assumptions here came from
+reading only Excel's output, and each one broke on openpyxl's:
+
+* **Attribute order carries no meaning.** Excel opens a relationship with
+  `Id`, openpyxl closes with it. Matching in a fixed order found nothing,
+  so a sheet looked as though it had no part behind it and loading to it
+  failed outright.
+* **An empty element may be written closed.** `<definedNames />` is the
+  same element as `<definedNames></definedNames>`. Appending a second
+  block beside it left two in the workbook, which Excel refuses.
+* **A namespace prefix is declared where it is used.** Excel puts
+  `xmlns:r` on every worksheet; openpyxl puts it on a worksheet that
+  needs one, and a sheet with no table does not. Adding a `tablePart`
+  that used the prefix made the part not well formed.
+
+Loading a query onto a sheet of a workbook openpyxl wrote works, and
+Excel opens and refreshes the result.
+
+**The other direction does not, and cannot be fixed here.** openpyxl
+rebuilds the package from the parts it models and drops the rest, custom
+XML included, so saving a workbook through it removes the Power Query
+package and the queries with it. Nothing signals this: the file opens and
+simply has no queries. Put pyOpenVBA last in the pipeline, or carry the
+queries across with `pull_queries()` and `push_queries()`.
+
+## `[trash]` parts
+
+Excel's own file recovery leaves the parts it threw out under
+`[trash]/NNNN.dat`, beside the real ones. An OPC part name cannot open a
+segment with a bracket, and Excel holds itself to that when reading: the
+same workbook opens before such an entry is added and fails to open at
+all after, measured both ways.
+
+The container preserves every entry as it arrived, which would hand back
+a file that stays broken, so `save()` drops these and warns. Nothing in
+the document depends on them: they carry no content type and no
+relationship points at them.
+
 ## What Excel refuses
 
 * A query name containing a dot. `Queries.Add` rejects it with

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyOpenVBA"
-version = "5.1.3"
+version = "5.2.1"
 description = "Read and write VBA macros and Excel Power Query in pure Python, no dependencies."
 readme = "README.md"
 license = { text = "MIT" }
@@ -61,6 +61,10 @@ dev = [
     "pyright>=1.1.350",
     "build>=1.2",
     "twine>=5",
+    # Test-time only, and the runtime keeps its promise of no dependencies.
+    # openpyxl writes the same parts a different legal way, which is what
+    # the interop tests are for.
+    "openpyxl>=3.1",
 ]
 
 [project.urls]

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/src/pyopenvba/__init__.py

@@ -291,4 +291,4 @@ def push_power_query(
     """
     return _push_queries(src_dir, workbook, out=out, encoding=encoding, remove_missing=remove_missing)
 
-__version__ = "5.1.3"
+__version__ = "5.2.1"

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/src/pyopenvba/access/_vba.py

@@ -368,6 +368,12 @@ def rename_attribute(text: str, old: str, new: str) -> str:
 
 
 # --- PROJECTwm and PROJECT --------------------------------------------------
+#: How PROJECT names the module behind a form or report: the keyword, the
+#: module's name, a slash, and a flag word Access owns.  A design's module
+#: is listed this way and never as ``Module=`` or ``Class=``.
+DOC_CLASS = "DocClass"
+#: The three keywords that open the module block.
+MODULE_KEYWORDS = ("Module=", "Class=", DOC_CLASS + "=")
 
 
 def project_wm_entry(name: str, encoding: str) -> bytes:
@@ -395,34 +401,56 @@ def rename_project_wm(payload: bytes, old: str, new: str, encoding: str) -> byte
 def add_to_project(text: str, name: str, kind: str) -> str:
     """Access lists a standard module as ``Module=`` and a class as
     ``Class=``, both in the same block, and gives each a window rectangle
-    under ``[Workspace]``."""
+    under ``[Workspace]``.
+
+    The block can be empty -- delete a project's last module and there is
+    no line to sit after -- and Access opens it right below the ``ID=``
+    line, which is where the first one goes.
+    """
     lines = text.split(CRLF)
-    last = max(i for i, line in enumerate(lines) if line.startswith(("Module=", "Class=")))
-    lines.insert(last + 1, ("Class=" if kind == "class" else "Module=") + name)
+    entry = ("Class=" if kind == "class" else "Module=") + name
+    listed = [i for i, line in enumerate(lines) if line.startswith(MODULE_KEYWORDS)]
+    if listed:
+        lines.insert(max(listed) + 1, entry)
+    else:
+        opener = next((i for i, line in enumerate(lines) if line.startswith("ID=")), -1)
+        lines.insert(opener + 1, entry)
     if any(line.strip() == "[Workspace]" for line in lines):
         lines.insert(len(lines) - 1, f"{name}=38, 38, 1786, 1030, ")
     return CRLF.join(lines)
 
 
 def remove_from_project(text: str, name: str) -> str:
+    """Every line naming a module: its ``Module=``, ``Class=`` or
+    ``DocClass=`` line, and its ``[Workspace]`` rectangle."""
     lines = [
         line
         for line in text.split(CRLF)
         if line not in (f"Module={name}", f"Class={name}")
+        and not line.startswith(f"{DOC_CLASS}={name}/")
         and not re.match(re.escape(name) + "=", line)
     ]
     return CRLF.join(lines)
 
 
 def rename_project(text: str, old: str, new: str) -> str:
-    """The ``Module=``/``Class=`` line and the ``[Workspace]`` line.  The
-    stream's lines end CR LF, so the end anchor has to allow the CR."""
+    """The ``Module=``, ``Class=`` or ``DocClass=`` line and the
+    ``[Workspace]`` line.  The stream's lines end CR LF, so the end anchor
+    has to allow the CR.
+
+    A design's module is listed only as ``DocClass=<name>/<flags>``, never
+    as ``Module=`` or ``Class=``.  Renaming without reaching it leaves a
+    DocClass naming a module the project no longer has, which Access
+    reports as a corrupt project on the first VBE reference (GitHub issue
+    #21).  The flag word after the slash is Access's, so the match stops
+    at it and it is carried through.
+    """
+    quoted = re.escape(old)
     tail = "(?=" + chr(92) + "r?$)"
     for keyword in ("Module", "Class"):
-        text = re.sub(
-            "(?m)^" + keyword + "=" + re.escape(old) + tail, keyword + "=" + new, text
-        )
-    return re.sub("(?m)^" + re.escape(old) + "=", new + "=", text)
+        text = re.sub("(?m)^" + keyword + "=" + quoted + tail, keyword + "=" + new, text)
+    text = re.sub("(?m)^" + DOC_CLASS + "=" + quoted + "(?=/)", DOC_CLASS + "=" + new, text)
+    return re.sub("(?m)^" + quoted + "=", new + "=", text)
 
 
 # --- the folder list ---------------------------------------------------------
@@ -476,22 +504,24 @@ def document_attributes(name: str, clsid: str) -> list[str]:
 def add_to_project_documents(text: str, name: str) -> str:
     """A `DocClass=` line, and a window rectangle under `[Workspace]`."""
     lines = text.split(CRLF)
-    last = max(
-        i
-        for i, line in enumerate(lines)
-        if line.startswith(("Module=", "Class=", "DocClass="))
-    )
-    lines.insert(last + 1, f"DocClass={name}{DOC_CLASS_SUFFIX}")
+    last = max(i for i, line in enumerate(lines) if line.startswith(MODULE_KEYWORDS))
+    lines.insert(last + 1, f"{DOC_CLASS}={name}{DOC_CLASS_SUFFIX}")
     if any(line.strip() == "[Workspace]" for line in lines):
         lines.insert(len(lines) - 1, f"{name}={DOC_WORKSPACE}")
     return CRLF.join(lines)
 
 
 def remove_from_project_documents(text: str, name: str) -> str:
+    """A document module's ``DocClass=`` line and its workspace rectangle.
+
+    Matched on the prefix, because the flag word after the slash and the
+    rectangle are Access's and a database it has edited need not carry the
+    ones written here.
+    """
     return CRLF.join(
         line
         for line in text.split(CRLF)
-        if line != f"DocClass={name}{DOC_CLASS_SUFFIX}" and line != f"{name}={DOC_WORKSPACE}"
+        if not line.startswith(f"{DOC_CLASS}={name}/") and not line.startswith(f"{name}=")
     )
 
 

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/src/pyopenvba/access/database.py

@@ -2641,6 +2641,43 @@ class AccessDatabase:
         footer sections."""
         return AccessForm(self, self._create_design("report", name, updated=updated))
 
+    def _list_in_container(
+        self, container: int, name: str, folder: str, when: dt.datetime | float
+    ) -> None:
+        """Name an object in its container's listing and claim its folder
+        in the container's folder list, creating either stream when the
+        container has none yet.
+
+        A container that has never held an object carries neither, so a
+        module added to a project with none went unlisted, and Access
+        showed nothing under `AllModules` for a module its VBE still
+        listed (GitHub issue #21).
+        """
+        storage = self.table(STORAGE_TABLE)
+        adders: tuple[tuple[str, Callable[[bytes], bytes]], ...] = (
+            (DIR_DATA, lambda payload: add_to_dir_data(payload, name, folder)),
+            ("PropData", lambda payload: add_to_folder_list(payload, folder)),
+        )
+        for stream, add in adders:
+            found = next(
+                (
+                    (rid, row.get("Lv"))
+                    for rid, row in storage.rows_with_ids()
+                    if _as_int(row["ParentId"]) == container and str(row["Name"]) == stream
+                ),
+                None,
+            )
+            if found is None:
+                storage.insert_row(
+                    {"ParentId": container, "Name": stream, "Type": TYPE_VALUE,
+                     "Lv": add(bytes(4)), "DateCreate": when, "DateUpdate": when}
+                )
+            else:
+                rid, payload = found
+                storage.update_row(
+                    rid, {"Lv": add(payload if isinstance(payload, bytes) else bytes(4))}
+                )
+
     def _create_design(self, kind: str, name: str, *, updated: object | None) -> AccessDesign:
         """The design itself comes from a captured template -- an empty one
         as Access writes it -- with a GUID of its own patched in, since the
@@ -2686,29 +2723,7 @@ class AccessDatabase:
                 values["Lv"] = payload
             storage.insert_row(values)
 
-        adders: tuple[tuple[str, Callable[[bytes], bytes]], ...] = (
-            (DIR_DATA, lambda payload: add_to_dir_data(payload, name, folder)),
-            ("PropData", lambda payload: add_to_folder_list(payload, folder)),
-        )
-        for stream, add in adders:
-            found = next(
-                (
-                    (rid, row.get("Lv"))
-                    for rid, row in storage.rows_with_ids()
-                    if _as_int(row["ParentId"]) == container and str(row["Name"]) == stream
-                ),
-                None,
-            )
-            if found is None:
-                storage.insert_row(
-                    {"ParentId": container, "Name": stream, "Type": TYPE_VALUE,
-                     "Lv": add(bytes(4)), "DateCreate": when, "DateUpdate": when}
-                )
-            else:
-                rid, payload = found
-                storage.update_row(
-                    rid, {"Lv": add(payload if isinstance(payload, bytes) else bytes(4))}
-                )
+        self._list_in_container(container, name, folder, when)
 
         objects = self.table("MSysObjects")
         parent = next(e.id for e in self.catalog() if e.name == CATALOG_CONTAINERS[kind] and e.type == 3)
@@ -2988,6 +3003,99 @@ class AccessDatabase:
         return self.module(name)
 
 
+    def _delete_module_streams(self, module: VBAModule) -> None:
+        """Take a module out of the VBA project alone: its stream row, its
+        dir block, its PROJECTwm entry, and whichever line of PROJECT
+        names it.
+
+        The Modules container is deliberately untouched, because the code
+        behind a form or report is listed in neither container: the
+        project carries `Form_Calculator` while the Forms listing carries
+        `Calculator`.
+        """
+        storage = self.table(STORAGE_TABLE)
+        encoding = encoding_of(self._vba_dir()[1])
+        _modules, project_id, streams_id = self._vba_storage_ids()
+        for rid, row in list(storage.rows_with_ids()):
+            value = row.get("Lv")
+            row_name, parent = str(row["Name"]), _as_int(row["ParentId"])
+            if parent == streams_id and row_name == module.stream_name:
+                storage.delete_row(rid, retire_empty=False)
+                continue
+            if not isinstance(value, bytes) or not value:
+                continue
+            if row_name == "dir":
+                storage.update_row(
+                    rid, {"Lv": compress(remove_from_dir(decompress(value), module.name))}
+                )
+            elif row_name == "_VBA_PROJECT":
+                storage.update_row(rid, {"Lv": invalidate_cache(value)})
+            elif row_name == "PROJECTwm" and parent == project_id:
+                storage.update_row(rid, {"Lv": remove_from_project_wm(value, module.name, encoding)})
+            elif row_name == "PROJECT" and parent == project_id:
+                text = value.decode(encoding, errors="replace")
+                fixed = remove_from_project(text, module.name)
+                if fixed != text:
+                    storage.update_row(rid, {"Lv": encode_mbcs(fixed, encoding)})
+        self._drop_srp()
+
+    def _design_module(self, kind: str, name: str) -> VBAModule | None:
+        """The module behind a design, if Access ever opened a code window
+        for it.  A design that has none simply has no such module."""
+        wanted = self.DESIGN_MODULE_PREFIX[kind] + name
+        return next(
+            (module for module in self.modules() if module.name.lower() == wanted.lower()),
+            None,
+        )
+
+    def rename_form(self, name: str, new_name: str) -> None:
+        """Rename a form everywhere its name lives."""
+        self._rename_design("form", name, new_name)
+
+    def rename_report(self, name: str, new_name: str) -> None:
+        """Rename a report everywhere its name lives."""
+        self._rename_design("report", name, new_name)
+
+    def _rename_design(self, kind: str, name: str, new_name: str) -> None:
+        """A design's name lives in four places: its container's listing,
+        its catalog row, its navigation-pane row, and the module behind
+        it, which Access binds by name as `Form_<name>` or
+        `Report_<name>`.
+
+        A design Access has never opened a code window for has no module,
+        and then there are three.  The module is the part with the sharp
+        edge: `PROJECT` names it only as a `DocClass=` line, and leaving
+        that naming a module the project no longer has makes Access report
+        the whole project as corrupt on the first VBE reference (GitHub
+        issue #21).
+        """
+        if not new_name or len(new_name) > 64:
+            raise AccessError(f"a {kind} name is 1 to 64 characters")
+        found = self._design(kind, name)
+        if new_name.lower() != found.name.lower() and any(
+            other.name.lower() == new_name.lower() for other in self._designs(kind)
+        ):
+            raise AccessError(f"a {kind} named {new_name!r} already exists")
+
+        module = self._design_module(kind, found.name)
+        if module is not None:
+            self._rename_module_streams(module, self.DESIGN_MODULE_PREFIX[kind] + new_name)
+
+        container = self._design_container(kind)
+        storage = self.table(STORAGE_TABLE)
+        for rid, row in list(storage.rows_with_ids()):
+            value = row.get("Lv")
+            if (
+                isinstance(value, bytes)
+                and value
+                and str(row["Name"]) == DIR_DATA
+                and _as_int(row["ParentId"]) == container
+            ):
+                storage.update_row(rid, {"Lv": rename_dir_data(value, found.name, new_name)})
+        self._rename_catalog_rows(found.name, new_name, OBJECT_TYPES[kind])
+        self.forget_catalog()
+        self._drop_srp()
+
     def delete_form(self, name: str) -> None:
         """Remove a form and every structure it occupies."""
         self._delete_design("form", name)
@@ -2998,6 +3106,13 @@ class AccessDatabase:
 
     def _delete_design(self, kind: str, name: str) -> None:
         found = self._design(kind, name)
+        # The module behind it goes too, or the project is left naming a
+        # DocClass whose design is gone, which Access reads as corrupt
+        # (GitHub issue #21).  It has to go first, while the design is
+        # still there to name it.
+        module = self._design_module(kind, found.name)
+        if module is not None:
+            self._delete_module_streams(module)
         container = self._design_container(kind)
         storage = self.table(STORAGE_TABLE)
         listing_rid, listing_payload = next(
@@ -4031,12 +4146,6 @@ class AccessDatabase:
             row_name, parent = str(row["Name"]), _as_int(row["ParentId"])
             if row_name == "_VBA_PROJECT":
                 storage.update_row(rid, {"Lv": invalidate_cache(payload)})
-            elif row_name == "\x03DirData" and parent == modules_id:
-                # The four bytes an entry ends with name the object's
-                # storage folder, not a terminator.
-                storage.update_row(rid, {"Lv": add_to_dir_data(payload, name, folder)})
-            elif row_name == "PropData" and parent == modules_id:
-                storage.update_row(rid, {"Lv": add_to_folder_list(payload, folder)})
             elif row_name == "PROJECTwm" and parent == project_id:
                 storage.update_row(rid, {"Lv": add_to_project_wm(payload, name, encoding)})
             elif row_name == "PROJECT" and parent == project_id:
@@ -4051,6 +4160,9 @@ class AccessDatabase:
                         )
                     },
                 )
+        # The four bytes an entry ends with name the object's storage
+        # folder, not a terminator.
+        self._list_in_container(modules_id, name, folder, when)
         storage.update_row(
             dir_rid,
             {"Lv": compress(add_to_dir(dir_stream, dir_block(name, stream_name, cookie, kind, encoding)))},
@@ -4098,16 +4210,16 @@ class AccessDatabase:
         self._invalidate_vba_cache()
         self._drop_srp()
 
-    def rename_module(self, name: str, new_name: str) -> None:
-        """Rename a module in all eight places its name lives."""
-        if not new_name or len(new_name) > 64:
-            raise AccessError("a module name is 1 to 64 characters")
-        module = self.module(name)
-        if new_name.lower() != name.lower() and any(
-            other.name.lower() == new_name.lower() for other in self.modules()
-        ):
-            raise AccessError(f"a module named {new_name!r} already exists")
+    def _rename_module_streams(self, module: VBAModule, new_name: str) -> None:
+        """Rename a module wherever the VBA project itself names it: the
+        two dir records, the module's own `Attribute VB_Name`, PROJECT and
+        PROJECTwm.
 
+        The Modules listing is deliberately left alone here, because the
+        code behind a form or report appears in neither container listing:
+        the project carries `Form_Calculator` while the Forms listing
+        carries `Calculator`.
+        """
         storage = self.table(STORAGE_TABLE)
         dir_rid, dir_stream = self._vba_dir()
         encoding = encoding_of(dir_stream)
@@ -4120,7 +4232,7 @@ class AccessDatabase:
         stream = set_module_offset(rename_in_dir(dir_stream, module.name, new_name), new_name, 0)
         storage.update_row(dir_rid, {"Lv": compress(stream)})
 
-        modules_id, project_id, _streams = self._vba_storage_ids()
+        _modules, project_id, _streams = self._vba_storage_ids()
         for row_rid, row in list(storage.rows_with_ids()):
             value = row.get("Lv")
             if not isinstance(value, bytes) or not value:
@@ -4128,8 +4240,6 @@ class AccessDatabase:
             row_name, parent = str(row["Name"]), _as_int(row["ParentId"])
             if row_name == "_VBA_PROJECT":
                 storage.update_row(row_rid, {"Lv": invalidate_cache(value)})
-            elif row_name == "\x03DirData" and parent == modules_id:
-                storage.update_row(row_rid, {"Lv": rename_dir_data(value, module.name, new_name)})
             elif row_name == "PROJECTwm" and parent == project_id:
                 storage.update_row(
                     row_rid, {"Lv": rename_project_wm(value, module.name, new_name, encoding)}
@@ -4140,16 +4250,42 @@ class AccessDatabase:
                 if fixed != text:
                     storage.update_row(row_rid, {"Lv": encode_mbcs(fixed, encoding)})
 
+    def _rename_catalog_rows(self, old: str, new: str, object_type: int) -> None:
+        """The object's catalog row and its navigation-pane row."""
         objects = self.table("MSysObjects")
         for row_rid, row in objects.rows_with_ids():
-            if row["Type"] == OBJECT_MODULE and str(row["Name"]) == module.name:
-                objects.update_row(row_rid, {"Name": new_name})
+            if row["Type"] == object_type and str(row["Name"]) == old:
+                objects.update_row(row_rid, {"Name": new})
                 break
         nav = self.table("MSysNavPaneObjectIDs")
         for row_rid, row in nav.rows_with_ids():
-            if str(row["Name"]) == module.name:
-                nav.update_row(row_rid, {"Name": new_name})
+            if str(row["Name"]) == old:
+                nav.update_row(row_rid, {"Name": new})
                 break
+
+    def rename_module(self, name: str, new_name: str) -> None:
+        """Rename a module in all eight places its name lives."""
+        if not new_name or len(new_name) > 64:
+            raise AccessError("a module name is 1 to 64 characters")
+        module = self.module(name)
+        if new_name.lower() != name.lower() and any(
+            other.name.lower() == new_name.lower() for other in self.modules()
+        ):
+            raise AccessError(f"a module named {new_name!r} already exists")
+
+        self._rename_module_streams(module, new_name)
+        storage = self.table(STORAGE_TABLE)
+        modules_id = self._vba_storage_ids()[0]
+        for row_rid, row in list(storage.rows_with_ids()):
+            value = row.get("Lv")
+            if (
+                isinstance(value, bytes)
+                and value
+                and str(row["Name"]) == DIR_DATA
+                and _as_int(row["ParentId"]) == modules_id
+            ):
+                storage.update_row(row_rid, {"Lv": rename_dir_data(value, module.name, new_name)})
+        self._rename_catalog_rows(module.name, new_name, OBJECT_MODULE)
         self._drop_srp()
         self._catalog = None
 

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/src/pyopenvba/powerquery/_opc.py

@@ -29,6 +29,9 @@ _STORED = 0
 _FLAGS = 0x0006
 _MADE_BY = 45
 _NEEDED = 20
+#: Where Excel's file recovery parks the parts it threw out.  Not a legal
+#: OPC part name, and Excel will not open a package holding one.
+_RESERVED = "[trash]/"
 
 
 @dataclass
@@ -174,6 +177,28 @@ class OpcFile:
             self.entries = kept
             self.source = None
 
+    def drop_reserved(self) -> list[str]:
+        """Take out entries whose names are not part names, and say which.
+
+        Excel's own file recovery leaves `[trash]/NNNN.dat` beside the
+        real parts.  An OPC part name is built of segments that cannot
+        open with a bracket, and Excel holds itself to that when reading:
+        a workbook that opens cleanly stops opening at all once such an
+        entry is added, which is measured both ways in
+        `tests/test_powerquery_opc.py`.
+
+        Nothing in the document depends on them.  They carry no content
+        type and no relationship points at them, so a package is repaired
+        by dropping them rather than damaged.
+        """
+        doomed = [entry.name for entry in self.entries if entry.name.startswith(_RESERVED)]
+        if doomed:
+            self.entries = [
+                entry for entry in self.entries if not entry.name.startswith(_RESERVED)
+            ]
+            self.source = None
+        return doomed
+
     def serialize(self) -> bytes:
         if self.source is not None:
             return self.source

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/src/pyopenvba/powerquery/_sheets.py

@@ -102,6 +102,38 @@ def _relationships(package: OpcFile, part: str) -> str:
     )
 
 
+def _attributes(element: str) -> dict[str, str]:
+    """The attributes of one element, in whatever order they were written.
+
+    XML gives attribute order no meaning, and writers differ: Excel opens
+    a relationship with ``Id``, openpyxl closes with it.  Matching them in
+    a fixed order silently found nothing in the second case, which left a
+    sheet looking as though it had no part behind it.
+    """
+    return dict(re.findall(r'([\w.:-]+)\s*=\s*"([^"]*)"', element))
+
+
+def _relationship_targets(rels: str) -> dict[str, str]:
+    """``{relationship id: target}`` for one ``.rels`` part."""
+    out: dict[str, str] = {}
+    for element in re.findall(r"<Relationship\b[^>]*>", rels):
+        attributes = _attributes(element)
+        identifier, target = attributes.get("Id"), attributes.get("Target")
+        if identifier and target is not None:
+            out[identifier] = target
+    return out
+
+
+def _relationship_for(rels: str, target: str) -> str | None:
+    """The id pointing at ``target``, comparing the part it names rather
+    than the spelling: a target may be relative or absolute."""
+    wanted = target.lstrip("/").removeprefix("../")
+    for identifier, found in _relationship_targets(rels).items():
+        if found.lstrip("/").removeprefix("../") == wanted:
+            return identifier
+    return None
+
+
 def add_relationship(package: OpcFile, part: str, kind: str, target: str) -> str:
     raw = _relationships(package, part)
     identifier = _next_relationship(raw)
@@ -142,8 +174,17 @@ def sheet_part(package: OpcFile, sheet: str | int) -> tuple[str, str]:
     name of the sheet."""
     workbook = package.read(_WORKBOOK).decode("utf-8")
     rels = package.read(_WORKBOOK_RELS).decode("utf-8")
-    targets = dict(re.findall(r'<Relationship Id="([^"]+)"[^>]*Target="([^"]+)"', rels))
-    sheets = re.findall(r'<sheet\b[^>]*name="([^"]*)"[^>]*r:id="([^"]+)"', workbook)
+    targets = _relationship_targets(rels)
+    sheets: list[tuple[str, str]] = []
+    for element in re.findall(r"<sheet\b[^>]*>", workbook):
+        attributes = _attributes(element)
+        # The relationship attribute carries a namespace prefix, and which
+        # prefix is the writer's to choose.
+        identifier = next(
+            (value for key, value in attributes.items() if key.endswith(":id")), None
+        )
+        if "name" in attributes and identifier:
+            sheets.append((attributes["name"], identifier))
     if not sheets:
         raise PowerQueryError("this workbook lists no worksheets")
     if isinstance(sheet, int):
@@ -306,6 +347,7 @@ def _add_table_to_sheet(
         for index, column in enumerate(columns)
     )
     raw = _write_header(raw, header, start, len(columns))
+    raw = _declare_relationship_namespace(raw)
     if "<tableParts" in raw:
         raw = re.sub(
             r'<tableParts count="(\d+)">',
@@ -321,6 +363,28 @@ def _add_table_to_sheet(
     package.write(part, raw.encode("utf-8"))
 
 
+#: The namespace a `<tablePart r:id=...>` reference lives in.
+_RELATIONSHIPS_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+
+
+def _declare_relationship_namespace(sheet: str) -> str:
+    """Make sure the worksheet element declares the `r:` prefix.
+
+    Excel always writes it on the root element, so the reference added
+    below resolved.  openpyxl writes the prefix only where it uses one,
+    and a worksheet with no table has no use for it, which left the
+    `r:id` added here pointing at a prefix nothing declared.  That is not
+    well-formed XML, and Excel would not open the workbook at all.
+    """
+    opening = re.search(r"<worksheet\b[^>]*>", sheet)
+    if opening is None or 'xmlns:r=' in opening.group(0):
+        return sheet
+    fixed = opening.group(0).replace(
+        "<worksheet", f'<worksheet xmlns:r="{_RELATIONSHIPS_NS}"', 1
+    )
+    return sheet.replace(opening.group(0), fixed, 1)
+
+
 def _write_header(sheet: str, cells: str, start: CellRef, width: int) -> str:
     """Put the header cells on the sheet.
 
@@ -377,8 +441,14 @@ def _add_defined_name(package: OpcFile, sheet_name: str, number: int, reference:
         f'<definedName name="ExternalData_{number}" localSheetId="0" hidden="1">'
         f"{quoted}!{absolute}</definedName>"
     )
+    empty = re.search(r"<definedNames\s*/>", raw)
     if "<definedNames>" in raw:
         raw = raw.replace("<definedNames>", "<definedNames>" + defined)
+    elif empty is not None:
+        # An empty element written closed, which openpyxl does and Excel
+        # does not.  Appending a second block beside it puts two in the
+        # workbook, and Excel refuses that outright.
+        raw = raw.replace(empty.group(0), f"<definedNames>{defined}</definedNames>", 1)
     elif "<calcPr" in raw:
         raw = raw.replace("<calcPr", f"<definedNames>{defined}</definedNames><calcPr", 1)
     else:
@@ -407,16 +477,14 @@ def unload_from_sheet(package: OpcFile, query: str) -> bool:
         if not package.has(rels_part):
             continue
         rels = package.read(rels_part).decode("utf-8")
-        found = re.search(
-            rf'<Relationship Id="([^"]+)"[^>]*Target="\.\./tables/table{number}\.xml"[^>]*/>', rels
-        )
-        if found is None:
+        identifier = _relationship_for(rels, f"../tables/table{number}.xml")
+        if identifier is None:
             continue
         drop_relationship(package, rels_part, f"../tables/table{number}.xml")
         if "<Relationship " not in package.read(rels_part).decode("utf-8"):
             package.remove(rels_part)
         sheet = package.read(part).decode("utf-8")
-        sheet = re.sub(rf'<tablePart r:id="{found.group(1)}"\s*/>', "", sheet)
+        sheet = re.sub(rf'<tablePart\b[^>]*:id="{re.escape(identifier)}"[^>]*/>', "", sheet)
         sheet = re.sub(
             r'<tableParts count="(\d+)">',
             lambda match: f'<tableParts count="{max(int(match.group(1)) - 1, 0)}">',

{pyopenvba-5.1.3 → pyopenvba-5.2.1}/src/pyopenvba/powerquery/workbook.py

@@ -25,6 +25,7 @@ from __future__ import annotations
 import base64
 import re
 import uuid
+import warnings
 from pathlib import Path
 from typing import ClassVar
 from xml.etree import ElementTree
@@ -564,6 +565,20 @@ class PowerQueryWorkbook:
 
     def save(self, path: str | Path | None = None) -> Path:
         out = Path(path) if path is not None else self.path
+        # A workbook Excel has recovered carries the parts it threw out
+        # under `[trash]`, and Excel will not open a package holding one.
+        # Preserving those faithfully would hand back a file that stays
+        # broken, so they go, and the caller is told.
+        dropped = self._opc.drop_reserved()
+        if dropped:
+            warnings.warn(
+                "dropped "
+                + ", ".join(repr(name) for name in dropped)
+                + ": Excel's file recovery leaves those behind and will not "
+                "open a workbook that carries them",
+                UserWarning,
+                stacklevel=2,
+            )
         raw = self.to_bytes()
         out.write_bytes(raw)
         if path is None: