Merge branch 'dev'

Author: ShayHill

.pre-commit-config.yaml

@@ -45,7 +45,7 @@ repos:
         # files: .pre-commit-config.yaml
 
 - repo: https://github.com/pre-commit/mirrors-mypy
-  rev: v1.14.1
+  rev: v1.15.0
   hooks:
   - id: mypy
     name: mypy
@@ -61,7 +61,7 @@ repos:
     # files: ^(src/|tests/)
 
 - repo: https://github.com/PyCQA/isort
-  rev: 6.0.0
+  rev: 6.0.1
   hooks:
   - id: isort
     args: ["--profile", "black", "--filter-files", "--combine-as", "honor--noqa"]
@@ -133,7 +133,7 @@ repos:
   # C901 function is too complex  # for iter_at_depth
   # PLR0912 too many branches  # for iter_at_depth
   #
-  rev: 'v0.9.4'
+  rev: 'v0.11.9'
   hooks:
     - id: ruff
       exclude: "tests"
@@ -145,6 +145,6 @@ repos:
 
 # reads pyproject.toml for additional config
 - repo: https://github.com/RobertCraigie/pyright-python
-  rev: v1.1.393
+  rev: v1.1.400
   hooks:
     - id: pyright

docx2python/attribute_register.py

@@ -52,8 +52,11 @@ def get_localname(elem: EtreeElement) -> str:
     in `etree.QName`, this function will return a random string, and docx2python will
     silently ignore the element with the bad tag.
     """
+    tag = elem.tag
+    if isinstance(tag, bytearray):  # just for type checking
+        tag = tag.decode("utf-8")
     try:
-        qname = etree.QName(elem.tag)
+        qname = etree.QName(tag)
     except ValueError:
         warnings.warn(f"skipping invalid tag name '{elem.tag}'", stacklevel=2)
         return f"FAILED-{uuid.uuid4()}"

docx2python/depth_collector.py

@@ -189,7 +189,7 @@ def _runs_so_far(self) -> Iterator[str]:
         """
         for run_text in enum_at_depth(self.tree_text, 5):
             if run_text:
-                yield cast(str, run_text)
+                yield cast("str", run_text)
         for par in self._open_pars:
             yield from par.run_strings
 
@@ -291,7 +291,7 @@ def caret_depth(self) -> Literal[1, 2, 3, 4]:
         :return: from 0 to _par_depth, the depth of the last-closed element in the
             tree.
         """
-        return cast(Literal[1, 2, 3, 4], len(self._rightmost_branches))
+        return cast("Literal[1, 2, 3, 4]", len(self._rightmost_branches))
 
     @property
     def _open_runs(self) -> list[Run]:

docx2python/docx_context.py

@@ -174,12 +174,11 @@ def collect_rels(zipf: zipfile.ZipFile) -> dict[str, list[dict[str, str]]]:
         path2rels[rels] = [
             {str(y): str(z) for y, z in x.attrib.items()} for x in rels_elem
         ]
+        tag = rels_elem.tag
+        if isinstance(tag, bytearray):  # for type checkers
+            tag = tag.decode("utf-8")
         path2rels[rels].append(
-            {
-                "Id": "none",
-                "Type": etree.QName(rels_elem.tag).namespace or "",
-                "Target": rels,
-            }
+            {"Id": "none", "Type": etree.QName(tag).namespace or "", "Target": rels}
         )
 
     return path2rels

docx2python/docx_output.py

@@ -100,11 +100,11 @@ def _join_runs(tables: TextTable) -> list[list[list[list[str]]]]:
     """
     result: list[list[list[list[str]]]] = []
     for tbl in tables:
-        result.append(cast(list[list[list[str]]], []))
+        result.append(cast("list[list[list[str]]]", []))
         for row in tbl:
-            result[-1].append(cast(list[list[str]], []))
+            result[-1].append(cast("list[list[str]]", []))
             for cell in row:
-                result[-1][-1].append(cast(list[str], []))
+                result[-1][-1].append(cast("list[str]", []))
                 for par in cell:
                     result[-1][-1][-1].append("".join(par))
     return result

docx2python/docx_text.py

@@ -92,7 +92,7 @@ def search_at_depth(tree_: Sequence[EtreeElement], _depth: int = 0) -> int | Non
         grandchildren = [list(x) for x in tree_]
         return search_at_depth([x for y in grandchildren for x in y], _depth + 1)
 
-    return cast(Literal[1, 2, 3, 4], search_at_depth([tree]))
+    return cast("Literal[1, 2, 3, 4]", search_at_depth([tree]))
 
 
 def _get_text_below(file: File, root: EtreeElement) -> str:

docx2python/iterators.py

@@ -22,11 +22,12 @@
 from __future__ import annotations
 
 import copy
-from collections.abc import Iterable, Iterator
 from contextlib import suppress
 from typing import TYPE_CHECKING, Literal, TypeVar, cast, overload
 
 if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
     from docx2python.depth_collector import Par
 
     TextTable = list[list[list[list[list[str]]]]]
@@ -129,26 +130,26 @@ def enum_at_depth(
     ((1, 0, 1, 1), 'h')
     """
     if depth == 1:
-        nested = cast(Iterable[_T], nested)
+        nested = cast("Iterable[_T]", nested)
         yield from (((i,), x_1) for i, x_1 in enumerate(nested))
         return
     if depth == 2:
-        nested = cast(Iterable[Iterable[_T]], nested)
+        nested = cast("Iterable[Iterable[_T]]", nested)
         for i, x_2 in enumerate(nested):
             for j_2, y_2 in enum_at_depth(x_2, 1):
                 yield ((i, *j_2), y_2)
     elif depth == 3:
-        nested = cast(Iterable[Iterable[Iterable[_T]]], nested)
+        nested = cast("Iterable[Iterable[Iterable[_T]]]", nested)
         for i, x_3 in enumerate(nested):
             for j_3, y_3 in enum_at_depth(x_3, 2):
                 yield ((i, *j_3), y_3)
     elif depth == 4:
-        nested = cast(Iterable[Iterable[Iterable[Iterable[_T]]]], nested)
+        nested = cast("Iterable[Iterable[Iterable[Iterable[_T]]]]", nested)
         for i, x_4 in enumerate(nested):
             for j_4, y_4 in enum_at_depth(x_4, 3):
                 yield ((i, *j_4), y_4)
     elif depth == 5:
-        nested = cast(Iterable[Iterable[Iterable[Iterable[Iterable[_T]]]]], nested)
+        nested = cast("Iterable[Iterable[Iterable[Iterable[Iterable[_T]]]]]", nested)
         for i, x_5 in enumerate(nested):
             for j_5, y_5 in enum_at_depth(x_5, 4):
                 yield ((i, *j_5), y_5)
@@ -233,19 +234,19 @@ def iter_at_depth(
     ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
     """
     if depth == 1:
-        nested = cast(list[_T], nested)
+        nested = cast("list[_T]", nested)
         return (x for _, x in enum_at_depth(nested, depth))
     if depth == 2:
-        nested = cast(list[list[_T]], nested)
+        nested = cast("list[list[_T]]", nested)
         return (x for _, x in enum_at_depth(nested, depth))
     if depth == 3:
-        nested = cast(list[list[list[_T]]], nested)
+        nested = cast("list[list[list[_T]]]", nested)
         return (x for _, x in enum_at_depth(nested, depth))
     if depth == 4:
-        nested = cast(list[list[list[list[_T]]]], nested)
+        nested = cast("list[list[list[list[_T]]]]", nested)
         return (x for _, x in enum_at_depth(nested, depth))
     if depth == 5:
-        nested = cast(list[list[list[list[list[_T]]]]], nested)
+        nested = cast("list[list[list[list[list[_T]]]]]", nested)
         return (x for _, x in enum_at_depth(nested, depth))
     msg = "depth argument must be 1, 2, 3, 4, or 5"
     raise ValueError(msg)
@@ -385,24 +386,24 @@ def get_html_map(tables: TextTable) -> str:
     ``(0, 0, 0, 0) text``.
     """
     # prepend index tuple to each paragraph
-    tables_4deep = cast(list[list[list[list[str]]]], copy.deepcopy(tables))
+    tables_4deep = cast("list[list[list[list[str]]]]", copy.deepcopy(tables))
     for (i, j, k, m), paragraph in enum_at_depth(tables, 4):
         par_text = "".join(paragraph)
         tables_4deep[i][j][k][m] = " ".join([str((i, j, k, m)), par_text])
 
     # wrap each paragraph in <pre> tags
-    tables_3deep = cast(list[list[list[str]]], tables_4deep)
+    tables_3deep = cast("list[list[list[str]]]", tables_4deep)
     for (i, j, k), cell in enum_at_depth(tables_4deep, 3):
         cell_strs = (str(x) for x in cell)
         tables_3deep[i][j][k] = "".join([f"<pre>{x}</pre>" for x in cell_strs])
 
     # wrap each cell in <td> tags
-    tables_2deep = cast(list[list[str]], tables_3deep)
+    tables_2deep = cast("list[list[str]]", tables_3deep)
     for (i, j), row in enum_at_depth(tables_3deep, 2):
         tables_2deep[i][j] = "".join([f"<td>{x}</td>" for x in row])
 
     # wrap each row in <tr> tags
-    tables_1deep = cast(list[str], tables_2deep)
+    tables_1deep = cast("list[str]", tables_2deep)
     for (i,), table in enum_at_depth(tables_2deep, 1):
         tables_1deep[i] = "".join(f"<tr>{x}</tr>" for x in table)