Update app.py

app.py

@@ -1685,127 +1685,139 @@ def subject_is_singular(subj_token) -> bool:
 
 def fix_subject_verb_agreement(sent: str) -> str:
     """
-    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."
+    Repair singular subject + plural/base present verb after CMN1/SSCCV splits.
+    Handles: John are moving → John is moving; John live → John lives.
     """
-    doc = nlp(sent)
-    if not doc:
+    if not sent or not sent.strip():
         return sent
 
-    # --- subject: head of nsubj / nsubjpass on ROOT ---
-    root = next((t for t in doc if t.dep_ == "ROOT"), None)
-    if root is None:
+    sent = sent.strip()
+    doc = nlp(sent)
+    if not doc:
         return sent
 
+    # ----- identify subject head (prefer nsubj of ROOT) -----
+    root = next((t for t in doc if t.dep_ == "ROOT"), doc[0])
     subj = None
     for t in doc:
-        if t.dep_ in ("nsubj", "nsubjpass") and t.head == root:
+        if t.dep_ in ("nsubj", "nsubjpass") and (
+            t.head == root or t.head.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:
+    if subj is None:
+        for t in doc:
+            if t.dep_ in ("nsubj", "nsubjpass"):
                 subj = t
                 break
+
+    # Fallback: first proper/common noun or pronoun
     if subj is None:
         for t in doc:
-            if t.dep_ in ("nsubj", "nsubjpass"):
+            if t.tag_ in ("NNP", "NN", "PRP") and t.dep_ not in ("punct",):
                 subj = t
                 break
     if subj is None:
         return sent
 
-    # Still coordinated → leave plural verb alone
-    if any(c.dep_ == "cc" for c in subj.subtree):
+    # Coordinated subject → keep plural verb
+    if any(t.dep_ == "cc" for t in subj.subtree):
         return sent
 
-    # Singular subject?
     plural_pronouns = {"i", "you", "we", "they"}
     if subj.lower_ in plural_pronouns:
         return sent
     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")
 
+    # NNP / NN / singular PRP → singular
+    singular = subj.tag_ in ("NNP", "NN", "PRP")
     if not singular:
         return sent
 
-    # --- 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")
-        )
+    def to_3sg(word: str) -> str:
+        lower = word.lower()
+        irregular = {
+            "are": "is",
+            "were": "was",
+            "have": "has",
+            "do": "does",
+            "go": "goes",
+            "live": "lives",
+            "move": "moves",
+            "am": "is",
+        }
+        if lower in irregular:
+            new = irregular[lower]
+        elif lower.endswith(("s", "sh", "ch", "x", "z", "o")):
+            new = lower + "es"
+        elif lower.endswith("y") and len(lower) > 1 and lower[-2] not in "aeiou":
+            new = lower[:-1] + "ies"
+        else:
+            new = lower + "s"
+        if word[0].isupper():
+            new = new[0].upper() + new[1:]
+        return new
 
+    # ----- finite aux or main verb that should agree -----
     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
+    for t in doc:
+        if t.dep_ in ("aux", "auxpass") and t.tag_ in ("VBP", "VB", "VBD"):
+            # prefer aux of the main clause
+            if t.head == root or t.head.dep_ == "ROOT":
+                target = t
+                break
     if target is None:
         for t in doc:
-            if t.dep_ in ("aux", "auxpass") and t.tag_ in ("VBP", "VBZ", "VBD"):
+            if t.dep_ in ("aux", "auxpass") and t.lower_ in (
+                "are", "were", "have", "do", "am"
+            ):
                 target = t
                 break
+    if target is None and root.tag_ in ("VBP", "VB"):
+        target = root
     if target is None:
-        return sent
-
-    # 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
+        for t in doc:
+            if t.tag_ in ("VBP", "VB") and t.lower_ in (
+                "are", "were", "have", "do", "live", "go", "move"
+            ):
+                target = t
+                break
 
-    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"
+    if target is not None and target.tag_ != "VBZ":
+        if target.lower_ in ("is", "was", "has", "does"):
+            pass
         else:
-            new = lemma + "s"
-    else:
-        return sent
+            new = to_3sg(target.text)
+            sent = sent[: target.idx] + new + sent[target.idx + len(target.text) :]
+            # re-parse if you chain multiple fixes; for one shot this is enough
+            return sent
 
-    if target.text[0].isupper():
-        new = new[0].upper() + new[1:]
+    # ----- surface fallback (ungrammatical strings spaCy mis-parses) -----
+    # "John are …" / "Mary live …"
+    m = re.match(
+        r"^((?:The|A|An|His|Her|Their)\s+\w+|[A-Z][\w']*)\s+"
+        r"(are|were|have|do|live|move|go|want|need)\b",
+        sent,
+        flags=re.I,
+    )
+    if m:
+        subj_s, verb = m.group(1), m.group(2)
+        # skip if subject looks plural
+        if re.search(r"\b(and|&)\b", subj_s, re.I):
+            return sent
+        if re.search(r"s\s*$", subj_s) and not re.match(
+            r"^(His|Her|Their|The|A|An)\s", subj_s, re.I
+        ):
+            # weak; proper names end without s more often
+            pass
+        new_verb = to_3sg(verb)
+        if verb[0].isupper():
+            new_verb = new_verb[0].upper() + new_verb[1:]
+        sent = sent[: m.start(2)] + new_verb + sent[m.end(2) :]
 
-    return sent[: target.idx] + new + sent[target.idx + len(target.text) :]
+    return sent
+    
 ###############################################################################
 
 ###############################################################################