fix(diagram): don't duplicate shared edges when combining diagrams

On a MultiDiGraph, Diagram.__add__ used add_edges_from(arg.edges(data=True)),
which assigns a fresh parallel-edge key per call — so every FK shared between
two combined diagrams (they share the dependency graph) was duplicated, and a
single foreign key rendered as multiple overlapping edges. Merge edges by their
(u, v, key) instead, skipping ones already present.

Adds tests/integration/test_erd.py::test_diagram_operators_no_duplicate_edges
asserting +, +N, -N, *, add_parts, and from_sequence all preserve the
dependency graph's edge multiplicity.

Author: dimitri-yatsenko

src/datajoint/diagram.py

@@ -235,9 +235,15 @@ def __add__(self, arg) -> "Diagram":
         """
         result = Diagram(self)  # copy
         try:
-            # Merge nodes and edges from the other diagram
+            # Merge nodes and edges from the other diagram. Add edges by their
+            # multigraph key and skip ones already present: both operands derive
+            # from the same dependency graph, so a shared FK has the same
+            # (u, v, key) in each. Plain add_edges_from would mint a fresh key
+            # per call and duplicate every shared edge (parallel-edge bug).
             result.add_nodes_from(arg.nodes(data=True))
-            result.add_edges_from(arg.edges(data=True))
+            for u, v, key, edata in arg.edges(keys=True, data=True):
+                if not result.has_edge(u, v, key):
+                    result.add_edge(u, v, key=key, **edata)
             result.nodes_to_show.update(arg.nodes_to_show)
             # Merge contexts for class name lookups
             result.context = {**result.context, **arg.context}

tests/integration/test_erd.py

@@ -45,6 +45,35 @@ def test_diagram_algebra(schema_simp):
     assert diag4.nodes_to_show == set(cls.full_table_name for cls in (B.C, E.F, E.G, E.H, E.M))
 
 
+def test_diagram_operators_no_duplicate_edges(schema_simp):
+    """No diagram operator may duplicate a foreign-key edge.
+
+    Regression for the ``nx.MultiDiGraph`` migration: because a plain
+    ``add_edges_from`` mints a fresh parallel-edge key on every call, combining
+    diagrams (which share a dependency graph) doubled every shared FK, so a
+    single foreign key rendered as multiple overlapping edges. Each operator's
+    result must carry exactly the dependency graph's edge multiplicity for every
+    pair of tables.
+    """
+    deps = schema_simp.connection.dependencies
+    deps.load()
+
+    def assert_no_dupes(diag, label):
+        for u, v in {(u, v) for u, v in diag.edges()}:
+            assert diag.number_of_edges(u, v) == deps.number_of_edges(u, v), (
+                f"{label}: edge {u} -> {v} duplicated "
+                f"({diag.number_of_edges(u, v)} vs {deps.number_of_edges(u, v)} in deps)"
+            )
+
+    assert_no_dupes(dj.Diagram(schema_simp, context=LOCALS_SIMPLE), "Diagram(schema)")
+    assert_no_dupes(dj.Diagram(A) + dj.Diagram(B) + dj.Diagram(D), "union +")
+    assert_no_dupes(dj.Diagram(B) + 3, "downstream + N")
+    assert_no_dupes(dj.Diagram(E) - 3, "upstream - N")
+    assert_no_dupes((dj.Diagram(B) + 3) * (dj.Diagram(E) - 3), "intersection *")
+    assert_no_dupes((dj.Diagram(B) + E).add_parts(), "add_parts")
+    assert_no_dupes(dj.Diagram.from_sequence([A, B, D, E]), "from_sequence")
+
+
 def test_repr_svg(schema_adv):
     erd = dj.Diagram(schema_adv, context=dict())
     svg = erd._repr_svg_()