Sync addons-source@maintenance/gramps61 with upstream/gramps-project (2026-05-25)

Author: github-actions[bot]

GrampsWebSync/grampswebsync.gpr.py

@@ -28,7 +28,7 @@
     id="gramps_web_sync",
     name=_("Gramps Web Sync"),
     description=_("Synchronizes a local database with a Gramps Web instance."),
-    version = '1.3.11',
+    version = '1.3.12',
     gramps_target_version="6.1",
     status=STABLE,
     fname="grampswebsync.py",

GrampsWebSync/grampswebsync.py

@@ -180,6 +180,7 @@ def __init__(self, dbstate, user, options_class, name, *args, **kwargs) -> None:
 
         self.db1 = dbstate.db
         self.db2 = None
+        self._closing = False
         self._download_timestamp = 0
         self._changes: Actions | None = None
         self._sync: WebApiSyncDiffHandler | None = None
@@ -213,6 +214,14 @@ def build_menu_names(self, obj):  # type: ignore
     def do_close(self, assistant):
         """Close the assistant."""
         LOG.debug("Closing Gramps Web Sync addon.")
+        self._closing = True
+        if self.db2 is not None:
+            LOG.debug("Closing in-memory remote database.")
+            self.db2.close()
+            self.db2 = None
+        # Clear the diff handler which holds references to both db1 and db2
+        self._sync = None
+        self._changes = None
         position = self.window.get_position()  # crock
         self.assistant.hide()
         self.window.move(position[0], position[1])
@@ -500,6 +509,8 @@ def async_compare_dbs(self):
 
     def get_diff_actions(self) -> None:
         """Download the remote data, import it and compare it to local."""
+        if self._closing:
+            return
         LOG.info("Downloading Gramps XML file.")
         path = self.handle_server_errors(self.api.download_xml)
         if path is None:
@@ -545,6 +556,8 @@ def async_transfer_media(self):
 
     def _async_transfer_media(self):
         """Upload/download media files."""
+        if self._closing:
+            return
         self.handle_server_errors(self.download_files)
         if self.conclusion.error:
             return
@@ -665,6 +678,8 @@ def _async_commit_actions_to_remote(
         self, payload: dict[str, "Any"], force: bool
     ) -> None:
         """Upload/download media files."""
+        if self._closing:
+            return
         LOG.debug("Committing changes to remote database.")
         self.handle_server_errors(
             self.api.commit,

LinesOfDescendency/lines-of-descendency.gpr.py

@@ -33,7 +33,7 @@
         "Prints out all descendency lines "
         "from a given ancestor to a given descendent in text."
     ),
-    version = '1.1.41',
+    version = '1.1.42',
     gramps_target_version="6.1",
     status=STABLE,  # not yet tested with python 3
     fname="lines-of-descendency.py",

LinesOfDescendency/lines-of-descendency.py

@@ -126,7 +126,14 @@ def write_path(self, path):
                 mother if mother != handle \
                     else family.get_father_handle()
             handle = next_handle
-            spouse = self.database.get_person_from_handle(spouse_handle)
+            # Bug 12913: a family may have only one parent defined,
+            # in which case spouse_handle is None and
+            # get_person_from_handle raises HandleError. Guard the
+            # lookup so the existing "N.N." fallback still applies.
+            if spouse_handle:
+                spouse = self.database.get_person_from_handle(spouse_handle)
+            else:
+                spouse = None
             if spouse:
                 spouse_name = _nd.display(spouse)
             else:

LinesOfDescendency/tests/test_linesofdescendency_guards.py

@@ -127,5 +127,100 @@ def test_both_present_does_not_raise(self):
         self.assertIsNotNone(report.ancestor)
 
 
+class TestWritePathMissingSpouse(unittest.TestCase):
+    """Bug 12913: ``write_path`` raised ``HandleError: Handle is None``
+    when a family in the descent chain had only one parent defined
+    (so ``spouse_handle`` came back as ``None``) and the addon called
+    ``get_person_from_handle(None)`` directly. The guard added in
+    this PR catches the ``None`` before the lookup and falls through
+    to the existing ``'N.N.'`` spouse-name fallback that was already
+    in place for the "spouse object missing" case."""
+
+    @classmethod
+    def setUpClass(cls):
+        try:
+            cls.impl = _load_impl()
+        except ImportError as err:
+            raise unittest.SkipTest("Gramps not importable: %s" % err)
+        cls.LinesOfDescendency = cls.impl.LinesOfDescendency
+
+    @staticmethod
+    def _report_instance(database, doc):
+        """Build a ``LinesOfDescendency`` instance via ``__new__`` so
+        ``Report.__init__`` (which we don't need) doesn't run, and
+        wire up the minimum attributes ``write_path`` touches."""
+        report = TestWritePathMissingSpouse.LinesOfDescendency.__new__(
+            TestWritePathMissingSpouse.LinesOfDescendency
+        )
+        report.database = database
+        report.doc = doc
+        report.line = 1
+        return report
+
+    @staticmethod
+    def _person(handle, gramps_id, parents_family_handle):
+        """Mock person with the minimal API ``write_path`` touches."""
+        person = mock.MagicMock()
+        person.get_handle.return_value = handle
+        person.get_gramps_id.return_value = gramps_id
+        person.get_main_parents_family_handle.return_value = (
+            parents_family_handle
+        )
+        return person
+
+    @staticmethod
+    def _family(mother_handle, father_handle, relationship):
+        family = mock.MagicMock()
+        family.get_mother_handle.return_value = mother_handle
+        family.get_father_handle.return_value = father_handle
+        family.get_relationship.return_value = relationship
+        return family
+
+    def test_single_parent_family_does_not_raise(self):
+        """The reporter's case: a family in the chain has only one
+        parent defined. Pre-fix, ``get_person_from_handle(None)``
+        raised ``HandleError: Handle is None`` and torpedoed the
+        whole report."""
+        # Chain: ancestor (handle "A") -> child (handle "C")
+        # Family F0037 has father "A" and mother = None ("Reeves, Maria"
+        # removed per reporter's repro). When traversing from ancestor
+        # to child, spouse_handle resolves to None.
+        ancestor = self._person("A", "I0001", parents_family_handle=None)
+        child = self._person("C", "I0055", parents_family_handle="F0037")
+        # Family with only the father, no mother:
+        family = self._family(
+            mother_handle=None,
+            father_handle="A",
+            relationship=self.impl.FamilyRelType.MARRIED,
+        )
+
+        database = mock.MagicMock()
+        database.get_person_from_handle.side_effect = lambda h: {
+            "A": ancestor,
+            "C": child,
+        }[h]
+        database.get_family_from_handle.return_value = family
+
+        doc = mock.MagicMock()
+        report = self._report_instance(database, doc)
+
+        # Pre-fix this would raise HandleError; post-fix it must
+        # complete and never call get_person_from_handle with None.
+        report.write_path(["A", "C"])
+
+        # Verify get_person_from_handle was NEVER called with None
+        # -- the whole point of the guard.
+        for call in database.get_person_from_handle.call_args_list:
+            self.assertIsNotNone(call.args[0])
+
+        # Verify the user-visible output still uses the existing
+        # 'N.N.' fallback for the missing-spouse case.
+        written_calls = [str(c) for c in doc.write_text.call_args_list]
+        self.assertTrue(
+            any("N.N." in text for text in written_calls),
+            "Expected 'N.N.' fallback in rendered text; got %r" % written_calls,
+        )
+
+
 if __name__ == "__main__":
     unittest.main()

PDFForms/PDFForms.gpr.py

@@ -26,7 +26,7 @@
         "Generate blank fillable PDF forms: census/event forms or "
         "Ahnentafel pedigree charts."
     ),
-    version = '1.0.1',
+    version = '1.0.2',
     gramps_target_version="6.1",
     status=STABLE,
     fname="generatepdfform.py",
@@ -48,7 +48,7 @@
         "Import genealogy data from a PDF form. " 
         "Send the PDF template to others to fill out and return."
     ),
-    version = '1.0.1',
+    version = '1.0.2',
     gramps_target_version="6.1",
     status=STABLE,
     fname="importpdf.py",

PDFForms/generate_pdf.py

@@ -199,33 +199,82 @@ def _sanitize(text):
 
 
 MIN_COL_W = 20   # pt — minimum usable column width
+MAX_COL_W = 100  # pt — maximum column width (≈ 20 chars at 8 pt Helvetica)
 
 
 def _col_widths(columns, available_w):
-    """Return a list of point widths proportional to each column's <size>."""
+    """
+    Return column widths fitting *available_w*, clamped to [MIN_COL_W, MAX_COL_W].
+    Excess/deficit from clamped columns is redistributed iteratively among the rest.
+    """
     sizes = [c["size"] for c in columns]
     total = sum(sizes)
     if total > 0 and all(s > 0 for s in sizes):
-        return [available_w * s / total for s in sizes]
+        widths = [0.0] * len(sizes)
+        fixed = set()
+        for _ in range(len(sizes)):
+            free = [i for i in range(len(sizes)) if i not in fixed]
+            if not free:
+                break
+            fixed_sum = sum(widths[i] for i in fixed)
+            free_avail = available_w - fixed_sum
+            free_total = sum(sizes[i] for i in free)
+            if free_total <= 0:
+                break
+            did_clamp = False
+            for i in free:
+                w = free_avail * sizes[i] / free_total
+                if w < MIN_COL_W:
+                    widths[i] = MIN_COL_W
+                    fixed.add(i)
+                    did_clamp = True
+                elif w > MAX_COL_W:
+                    widths[i] = MAX_COL_W
+                    fixed.add(i)
+                    did_clamp = True
+                else:
+                    widths[i] = w
+            if not did_clamp:
+                break
+        return widths
     n = len(columns) or 1
     return [available_w / n] * len(columns)
 
 
 def _required_avail_w(columns):
     """
-    Return the minimum available_w so every proportional column >= MIN_COL_W.
-    Used to expand the page rather than squish columns.
+    Return the minimum available_w so every column fits within [MIN_COL_W, MAX_COL_W].
+
+    Each column is allocated ``clamp(size * MAX_COL_W / max_size)`` — proportional
+    to the largest column at MAX_COL_W — with a floor of MIN_COL_W.  Summing these
+    gives the page width where the iterative clamp in _col_widths converges cleanly.
     """
     sizes = [c["size"] for c in columns]
     pos = [s for s in sizes if s > 0]
     if not pos:
         return 0
-    return MIN_COL_W * sum(sizes) / min(pos)
+    max_s = max(pos)
+    return sum(
+        max(MIN_COL_W, min(MAX_COL_W, s * MAX_COL_W / max_s))
+        for s in sizes if s > 0
+    )
+
+
+def _split_camel(text):
+    """Insert spaces at camelCase boundaries: 'WindowRooms' → 'Window Rooms'."""
+    import re
+    return re.sub(r'([a-z])([A-Z])', r'\1 \2', text)
 
 
 def _wrap_text(text, max_width, canv, font, size):
-    """Break *text* into lines that fit within *max_width* points."""
-    words = text.split()
+    """
+    Break *text* into lines that fit within *max_width* points.
+
+    CamelCase tokens are split first so e.g. 'WindowRooms' wraps as
+    two words.  Words wider than *max_width* are kept whole — callers
+    that need overflow clipping should widen their clip rect accordingly.
+    """
+    words = _split_camel(text).split()
     lines, line = [], ""
     for word in words:
         candidate = (line + " " + word).strip()
@@ -293,18 +342,34 @@ def _draw_branding_header(canv, pw, y):
     return y
 
 
+def _fit_col_widths(columns, cws, canv):
+    """
+    Return column widths expanded so each column is at least as wide as its
+    wrapped header text: max(field_width, header_text_width).
+    """
+    result = []
+    for col_info, cw in zip(columns, cws):
+        lines = _wrap_text(col_info["attribute"], cw - 2, canv, "Helvetica-Bold", HEADER_SIZE)
+        display = lines[-HEADER_LINES:]
+        text_w = max(
+            canv.stringWidth(ln, "Helvetica-Bold", HEADER_SIZE) for ln in display
+        )
+        result.append(max(cw, text_w + 4))
+    return result
+
+
 def _draw_column_headers(canv, columns, col_widths, x0, y_top):
     """
     Draw column headers above a data grid, bottom-aligned within each column.
-    Each column is clipped to its own width so text never bleeds into neighbours.
+    Assumes col_widths have already been expanded via _fit_col_widths so no
+    text ever exceeds its column width.
     Returns the y coordinate of the bottom of the header block.
     """
     header_h = HEADER_LINES * (HEADER_SIZE + 1) + 2
     for col_info, cw in zip(columns, col_widths):
         lines = _wrap_text(col_info["attribute"], cw - 2, canv, "Helvetica-Bold", HEADER_SIZE)
         display = lines[-HEADER_LINES:]
 
-        # Clip this column so long words cannot bleed into the next column.
         canv.saveState()
         clip = canv.beginPath()
         clip.rect(x0, y_top - header_h, cw - 1, header_h)
@@ -435,7 +500,9 @@ def generate_form_pdf(form, rows, output_path):
 
     # ── Heading fields (form metadata) ─────────────────────────────────────
     if form["headings"]:
-        heading_w = avail_w / HEADING_PER_ROW
+        # Use the base (non-expanded) page width so heading fields stay
+        # a reasonable size regardless of how wide the data columns require.
+        heading_w = base_avail / HEADING_PER_ROW
         col = 0
         row_top = y
         for i, heading in enumerate(form["headings"]):
@@ -445,8 +512,8 @@ def generate_form_pdf(form, rows, output_path):
             # Label
             c.setFont("Helvetica", LABEL_SIZE)
             c.drawString(hx, row_top - LABEL_SIZE, label)
-            # Field
-            field_w = heading_w - lw - 2
+            # Field — cap at MAX_COL_W so headings stay compact
+            field_w = min(heading_w - lw - 2, MAX_COL_W)
             if field_w >= 20:
                 c.acroForm.textfield(
                     name=f"heading_{i}",
@@ -489,7 +556,7 @@ def generate_form_pdf(form, rows, output_path):
         c.drawString(MARGIN, y - (LABEL_SIZE + 1), title)
         y -= LABEL_SIZE + 1 + 3
 
-        cws = _col_widths(columns, avail_w)
+        cws = _fit_col_widths(columns, _col_widths(columns, avail_w), c)
 
         # ── family: Groom + Bride split ─────────────────────────────────
         if stype == "family":
@@ -500,7 +567,7 @@ def generate_form_pdf(form, rows, output_path):
             side_keys = ["Groom", "Bride"]
 
             for s_label, sx, sk in zip(side_labels, side_x, side_keys):
-                side_cws = _col_widths(columns, half_w)
+                side_cws = _fit_col_widths(columns, _col_widths(columns, half_w), c)
                 # Side sub-title
                 c.setFont("Helvetica-Bold", LABEL_SIZE)
                 c.drawString(sx, y - LABEL_SIZE, s_label or sk)
@@ -510,7 +577,7 @@ def generate_form_pdf(form, rows, output_path):
 
             # One data row per side
             for sx, sk in zip(side_x, side_keys):
-                side_cws = _col_widths(columns, half_w)
+                side_cws = _fit_col_widths(columns, _col_widths(columns, half_w), c)
                 _add_row_fields(c, columns, side_cws, sx, y, f"{role}_{sk}", "1")
             y -= ROW_HEIGHT