Update app.py

app.py

@@ -1685,55 +1685,127 @@ def subject_is_singular(subj_token) -> bool:
 
 def fix_subject_verb_agreement(sent: str) -> str:
     """
-    If the subject is singular and the finite verb is a plural present (VBP),
-    rewrite the verb to 3rd-person singular (lives, is, has, …).
-    Leaves past (VBD), progressives, etc. unchanged.
+    After CMN1 (and similar) splits a plural subject into singulars,
+    repair the matrix finite verb / agreeing auxiliary.
+    e.g. "The man are going home." → "The man is going home."
     """
-    if not sent or not sent.strip():
-        return sent
-
     doc = nlp(sent)
-    edits = []  # (token.i, new_text)
+    if not doc:
+        return sent
 
-    for tok in doc:
-        if tok.dep_ != "ROOT" and tok.dep_ not in ("ccomp", "xcomp", "advcl"):
-            # Prefer sentence ROOT finite verb
-            pass
+    # --- subject: head of nsubj / nsubjpass on ROOT ---
+    root = next((t for t in doc if t.dep_ == "ROOT"), None)
+    if root is None:
+        return sent
 
-    roots = [t for t in doc if t.dep_ == "ROOT"]
-    if not roots:
+    subj = None
+    for t in doc:
+        if t.dep_ in ("nsubj", "nsubjpass") and t.head == root:
+            subj = t
+            break
+        # subject may attach to aux in some parses
+        if t.dep_ in ("nsubj", "nsubjpass") and t.head.dep_ in ("aux", "auxpass"):
+            if t.head.head == root or t.head == root:
+                subj = t
+                break
+    if subj is None:
+        for t in doc:
+            if t.dep_ in ("nsubj", "nsubjpass"):
+                subj = t
+                break
+    if subj is None:
         return sent
-    verb = roots[0]
 
-    # Only repair untreated present plural / base used as present
-    if verb.tag_ not in ("VBP", "VB"):
+    # Still coordinated → leave plural verb alone
+    if any(c.dep_ == "cc" for c in subj.subtree):
         return sent
-    # Skip auxiliaries that are not the lexical main verb when better root exists
-    # (spaCy ROOT is usually the main verb or the finite aux)
 
-    subjs = [c for c in verb.children if c.dep_ in ("nsubj", "nsubjpass")]
-    if not subjs:
+    # Singular subject?
+    plural_pronouns = {"i", "you", "we", "they"}
+    if subj.lower_ in plural_pronouns:
         return sent
-    subj = subjs[0]
+    if subj.tag_ in ("NNS", "NNPS"):
+        return sent
+    singular = subj.tag_ in ("NN", "NNP", "PRP") or (
+        subj.tag_ in ("DT",) and False
+    )
+    # "the man", "his dog": head noun is NN/NNP
+    if subj.tag_ in ("NN", "NNP", "PRP"):
+        singular = True
+    elif subj.pos_ == "NOUN" and subj.tag_ == "NN":
+        singular = True
+    else:
+        # walk to noun head of subject chunk
+        head = subj
+        for t in subj.subtree:
+            if t.tag_ in ("NN", "NNP") and t.dep_ in ("nsubj", "nsubjpass", "ROOT"):
+                head = t
+        if head.tag_ in ("NNS", "NNPS"):
+            return sent
+        singular = head.tag_ in ("NN", "NNP", "PRP")
 
-    if not subject_is_singular(subj):
+    if not singular:
         return sent
 
-    lemma = verb.lemma_.lower()
-    new_form = _singular_present_form(lemma)
+    # --- finite form that must agree (aux or main verb) ---
+    def is_finite_agreeing(t):
+        return t.tag_ in ("VBP", "VBZ", "VBD", "MD") or (
+            t.pos_ in ("AUX", "VERB") and t.tag_ in ("VBP", "VBZ", "VBD")
+        )
 
-    # Preserve capitalisation
-    if verb.text and verb.text[0].isupper():
-        new_form = new_form[0].upper() + new_form[1:]
+    target = None
+    # Prefer aux/auxpass under ROOT (are going, has gone, …)
+    for t in root.children:
+        if t.dep_ in ("aux", "auxpass") and t.tag_ in ("VBP", "VBZ", "VBD"):
+            target = t
+            break
+    if target is None and root.tag_ in ("VBP", "VBZ", "VBD", "VB"):
+        target = root
+    if target is None:
+        for t in doc:
+            if t.dep_ in ("aux", "auxpass") and t.tag_ in ("VBP", "VBZ", "VBD"):
+                target = t
+                break
+    if target is None:
+        return sent
 
-    if new_form == verb.text:
+    # Already 3sg present or past that doesn't need change for singular
+    # We only rewrite clear plural/present-base forms
+    lower = target.text.lower()
+    irregular_to_3sg = {
+        "are": "is",
+        "were": "was",
+        "have": "has",
+        "do": "does",
+        "go": "goes",
+        "'re": "'s",
+        "am": "is",  # rare after split
+    }
+    # Past "was" already singular; "were" handled above
+    if lower in ("is", "was", "has", "does", "goes"):
+        return sent
+    if target.tag_ == "VBZ":
         return sent
 
-    pieces = [t.text_with_ws for t in doc]
-    # Replace only this token's text, keep its following whitespace
-    ws = verb.whitespace_
-    pieces[verb.i] = new_form + ws
-    return "".join(pieces).strip()
+    if lower in irregular_to_3sg:
+        new = irregular_to_3sg[lower]
+    elif target.tag_ in ("VBP", "VB"):
+        lemma = target.lemma_.lower()
+        if lemma in irregular_to_3sg:
+            new = irregular_to_3sg[lemma]
+        elif lemma.endswith(("s", "sh", "ch", "x", "z", "o")):
+            new = lemma + "es"
+        elif lemma.endswith("y") and len(lemma) > 1 and lemma[-2] not in "aeiou":
+            new = lemma[:-1] + "ies"
+        else:
+            new = lemma + "s"
+    else:
+        return sent
+
+    if target.text[0].isupper():
+        new = new[0].upper() + new[1:]
+
+    return sent[: target.idx] + new + sent[target.idx + len(target.text) :]
 ###############################################################################
 
 ###############################################################################
@@ -2559,13 +2631,8 @@ def process_text(input_text):
 
                     # Subject–verb agreement after coordinated-NP (CMN1) splits
                     if simps and xml_tag == "M:Y_CMN1":
-                        fixed = []
-                        for s in simps:
-                            s2 = fix_subject_verb_agreement(s)
-                            if s2 != s:
-                                print(f"  Agreement fix: {s!r} → {s2!r}")
-                            fixed.append(s2)
-                        simps = fixed
+                        simps = [fix_subject_verb_agreement(s) for s in simps]
+                    
 
                     if not simps:
                         print(
@@ -2585,6 +2652,7 @@ def process_text(input_text):
                                 f"  No progress (same as input): "
                                 f"{plain_s[:80]}..."
                             )
+                                plain_s = fix_subject_verb_agreement(plain_s)
                             sentence_final.append(plain_s)
                             continue
                         if plain_key in seen: