Update app.py

app.py

@@ -2733,95 +2733,114 @@ def expand_paren_lists(sent: str, lists: list[list[str]]) -> list[str]:
 
 ###############################################################################
 def build_shared_dag(sentences):
+    sents = [tuple(s.rstrip(".").split()) for s in sentences if s.strip()]
+    if not sents:
+        return {}, set()
+
+    # count every suffix
+    suffix_count = defaultdict(int)
+    for sent in sents:
+        for i in range(len(sent)):
+            suffix_count[sent[i:]] += 1
+
+    # keep full sentences, and any suffix that is truly shared
+    keep = set()
+    for sent in sents:
+        keep.add(sent)
+        for i in range(1, len(sent)):
+            if suffix_count[sent[i:]] > 1:
+                keep.add(sent[i:])
+
+    # also keep shared prefixes (length >= 2, count >= 2)
+    prefix_count = defaultdict(int)
+    for sent in sents:
+        for i in range(2, len(sent) + 1):
+            prefix_count[sent[:i]] += 1
+    for p, c in prefix_count.items():
+        if c >= 2:
+            keep.add(p)
+
     cache = {}
     labels = {}
+    def node_for(words):
+        if words not in cache:
+            nid = f"n{len(cache)}"
+            cache[words] = nid
+            labels[nid] = " ".join(words)
+        return cache[words]
+
     edges = set()
+    for sent in sents:
+        # walk the sentence, emitting an edge only when we hit a kept span
+        prev = None
+        for i in range(len(sent)):
+            span = sent[i:]
+            if span in keep:
+                nid = node_for(span)
+                if prev is not None:
+                    edges.add((prev, nid))
+                prev = nid
+        # also connect shared prefixes into the first kept continuation
+        for i in range(2, len(sent)):
+            pref = sent[:i]
+            if pref in keep:
+                # find the next kept span after this prefix
+                for j in range(i, len(sent)):
+                    if sent[j:] in keep:
+                        edges.add((node_for(pref), node_for(sent[j:])))
+                        break
 
-    def node_for(words):
-        key = tuple(words)
-        if key in cache:
-            return cache[key]
-        nid = f"n{len(cache)}"
-        cache[key] = nid
-        labels[nid] = " ".join(words) if words else ""
-        return nid
-
-    root = node_for([])
-    for sent in sentences:
-        words = sent.rstrip(".").split()
-        prev = root
-        for i in range(len(words)):
-            nxt = node_for(words[i:])
-            edges.add((prev, nxt))
-            prev = nxt
     return labels, edges
 ###############################################################################
 
 ###############################################################################
-def dag_to_svg(sentences, width=900):
+def dag_to_svg(sentences, width=1000):
     labels, edges = build_shared_dag(sentences)
-    # drop the empty root
-    nodes = [nid for nid, lab in labels.items() if lab]
-    # simple layered layout by first appearance
-    order = []
-    seen = set()
-    for sent in sentences:
-        words = sent.rstrip(".").split()
-        for i in range(len(words)):
-            key = tuple(words[i:])
-            # find nid
-            for nid, lab in labels.items():
-                if lab == " ".join(key) and nid not in seen:
-                    order.append(nid)
-                    seen.add(nid)
-                    break
-    for nid in nodes:
-        if nid not in seen:
-            order.append(nid)
+    if not labels:
+        return "<p>No sentences.</p>"
 
-    # group into rows by roughly similar remaining length
-    rows = {}
+    # order nodes by descending length so shared tails sit lower
+    order = sorted(labels.keys(), key=lambda n: -len(labels[n].split()))
+    # group into rows by word count
+    rows = defaultdict(list)
     for nid in order:
-        length = len(labels[nid].split())
-        rows.setdefault(length, []).append(nid)
+        rows[len(labels[nid].split())].append(nid)
     lengths = sorted(rows.keys(), reverse=True)
 
     positions = {}
-    y = 40
+    y = 30
+    max_w = 0
     for length in lengths:
         row = rows[length]
         n = len(row)
+        box_w = min(280, max(140, width // max(n, 1) - 20))
         for i, nid in enumerate(row):
-            x = 40 + i * (width - 80) / max(n, 1)
-            positions[nid] = (x, y)
-        y += 90
+            x = 20 + i * (box_w + 30)
+            positions[nid] = (x, y, box_w)
+            max_w = max(max_w, x + box_w)
+        y += 70
 
-    # SVG
     parts = [
-        f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{y + 20}" '
-        f'style="font-family:Helvetica,Arial,sans-serif;font-size:13px;">'
+        f'<svg xmlns="http://www.w3.org/2000/svg" width="{max(width, max_w + 40)}" '
+        f'height="{y + 20}" style="font-family:Helvetica,Arial,sans-serif;font-size:13px;">',
+        '<defs><marker id="arrow" markerWidth="8" markerHeight="8" refX="7" refY="3" '
+        'orient="auto"><path d="M0,0 L0,6 L8,3 z" fill="#888"/></marker></defs>',
     ]
-    # edges
     for a, b in edges:
         if a not in positions or b not in positions:
             continue
-        x1, y1 = positions[a]
-        x2, y2 = positions[b]
+        x1, y1, w1 = positions[a]
+        x2, y2, w2 = positions[b]
         parts.append(
-            f'<line x1="{x1+60}" y1="{y1+20}" x2="{x2+60}" y2="{y2}" '
+            f'<line x1="{x1 + w1/2}" y1="{y1 + 32}" x2="{x2 + w2/2}" y2="{y2}" '
             f'stroke="#888" stroke-width="1.2" marker-end="url(#arrow)"/>'
         )
-    parts.append(
-        '<defs><marker id="arrow" markerWidth="8" markerHeight="8" '
-        'refX="6" refY="3" orient="auto"><path d="M0,0 L0,6 L8,3 z" fill="#888"/></marker></defs>'
-    )
-    # nodes
-    for nid, (x, y) in positions.items():
+    for nid, (x, y, w) in positions.items():
         lab = labels[nid].replace("&", "&amp;").replace("<", "&lt;")
         parts.append(
-            f'<rect x="{x}" y="{y}" width="120" height="36" rx="6" '
+            f'<rect x="{x}" y="{y}" width="{w}" height="32" rx="5" '
             f'fill="#f7f7f7" stroke="#555"/>'
-            f'<text x="{x+60}" y="{y+22}" text-anchor="middle">{lab}</text>'
+            f'<text x="{x + w/2}" y="{y + 20}" text-anchor="middle">{lab}</text>'
         )
     parts.append("</svg>")
     return "".join(parts)