Update app.py

app.py

@@ -1685,8 +1685,9 @@ def subject_is_singular(subj_token) -> bool:
 
 def fix_subject_verb_agreement(sent: str) -> str:
     """
-    Repair singular subject + plural/base present verb after CMN1/SSCCV splits.
-    Handles: John are moving → John is moving; John live → John lives.
+    After CMN1 splits a plural subject, repair the finite verb / aux.
+    The man live …  → The man lives …
+    The man are going … → The man is going …
     """
     if not sent or not sent.strip():
         return sent
@@ -1696,47 +1697,25 @@ def fix_subject_verb_agreement(sent: str) -> str:
     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 or t.head.head == root
-        ):
-            subj = t
-            break
-    if subj is None:
-        for t in doc:
-            if t.dep_ in ("nsubj", "nsubjpass"):
-                subj = t
-                break
-
-    # Fallback: first proper/common noun or pronoun
+    # --- subject: first nsubj, else first noun ---
+    subj = next((t for t in doc if t.dep_ in ("nsubj", "nsubjpass")), None)
     if subj is None:
-        for t in doc:
-            if t.tag_ in ("NNP", "NN", "PRP") and t.dep_ not in ("punct",):
-                subj = t
-                break
+        subj = next((t for t in doc if t.tag_ in ("NN", "NNP", "PRP")), None)
     if subj is None:
         return sent
 
-    # Coordinated subject → keep plural verb
+    # Coordinated subject still plural
     if any(t.dep_ == "cc" for t in subj.subtree):
         return sent
-
-    plural_pronouns = {"i", "you", "we", "they"}
-    if subj.lower_ in plural_pronouns:
+    if subj.lower_ in {"i", "you", "we", "they"}:
         return sent
     if subj.tag_ in ("NNS", "NNPS"):
         return sent
-
-    # NNP / NN / singular PRP → singular
-    singular = subj.tag_ in ("NNP", "NN", "PRP")
-    if not singular:
+    if subj.tag_ not in ("NN", "NNP", "PRP"):
         return sent
 
     def to_3sg(word: str) -> str:
-        lower = word.lower()
+        low = word.lower()
         irregular = {
             "are": "is",
             "were": "was",
@@ -1744,80 +1723,39 @@ def fix_subject_verb_agreement(sent: str) -> str:
             "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"
+        if low in irregular:
+            new = irregular[low]
+        elif low.endswith(("s", "sh", "ch", "x", "z", "o")):
+            new = low + "es"
+        elif low.endswith("y") and len(low) > 1 and low[-2] not in "aeiou":
+            new = low[:-1] + "ies"
         else:
-            new = lower + "s"
-        if word[0].isupper():
+            new = low + "s"
+        if word[:1].isupper():
             new = new[0].upper() + new[1:]
         return new
 
-    # ----- finite aux or main verb that should agree -----
+    # Prefer agreeing AUX (are going, have gone, …)
     target = None
     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 t.dep_ in ("aux", "auxpass") and t.lower_ in {
+            "are", "were", "have", "do", "am"
+        }:
+            target = t
+            break
     if target is None:
         for t in doc:
-            if t.dep_ in ("aux", "auxpass") and t.lower_ in (
-                "are", "were", "have", "do", "am"
-            ):
+            if t.tag_ in ("VBP", "VB") and t.lower_ not in {"to"}:
                 target = t
                 break
-    if target is None and root.tag_ in ("VBP", "VB"):
-        target = root
     if target is None:
-        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 target is not None and target.tag_ != "VBZ":
-        if target.lower_ in ("is", "was", "has", "does"):
-            pass
-        else:
-            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
-
-    # ----- 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
+    if target.lower_ in {"is", "was", "has", "does"}:
+        return sent
 
-    return sent
-    
+    new = to_3sg(target.text)
+    return sent[: target.idx] + new + sent[target.idx + len(target.text) :]    
 ###############################################################################
 
 ###############################################################################
@@ -2376,78 +2314,6 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
 
 ###############################################################################
 
-###############################################################################
-def fix_subject_verb_agreement(sent: str) -> str:
-    """
-    If the finite verb is present plural (VBP) but the subject is singular,
-    rewrite the verb to singular present (lives, is, has, …).
-    """
-    doc = nlp(sent)
-    if not doc:
-        return sent
-
-    # Find root verb
-    root = None
-    for t in doc:
-        if t.dep_ == "ROOT" and t.pos_ in ("VERB", "AUX"):
-            root = t
-            break
-    if root is None:
-        return sent
-
-    # Only repair present non-3sg forms that look plural/base
-    if root.tag_ not in ("VBP", "VB"):
-        return sent
-
-    # Collect nsubj / nsubjpass text
-    subj_tokens = [t for t in root.lefts if t.dep_ in ("nsubj", "nsubjpass")]
-    if not subj_tokens:
-        return sent
-
-    subj = subj_tokens[0]
-    # Coordinated subject still plural → leave alone
-    if any(t.dep_ == "cc" for t in subj.subtree):
-        return sent
-
-    singular = subj.tag_ in ("NN", "NNP", "PRP") and subj.lower_ not in (
-        "i", "you", "we", "they",
-    )
-    # "I/you" take VBP; don't force -s
-    if subj.lower_ in ("i", "you", "we", "they"):
-        return sent
-    if not singular and subj.tag_ not in ("NN", "NNP"):
-        # Heuristic: plural NNS / NNPS → keep verb
-        if subj.tag_ in ("NNS", "NNPS"):
-            return sent
-
-    if not singular and subj.tag_ not in ("NN", "NNP", "PRP"):
-        return sent
-
-    # Map verb → 3sg present
-    irregular = {
-        "are": "is", "were": "was", "have": "has", "do": "does",
-        "go": "goes", "do": "does",
-    }
-    lemma = root.lemma_.lower()
-    form = root.text
-    lower = form.lower()
-
-    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 form[0].isupper():
-        new = new[0].upper() + new[1:]
-
-    # Splice back into the sentence using character offsets
-    return sent[: root.idx] + new + sent[root.idx + len(root.text) :]
-###############################################################################
-
 ###############################################################################
 @spaces.GPU(duration=120)
 def process_text(input_text):