Update app.py

app.py

@@ -47,7 +47,7 @@ The demo loops infinitely when more than 1 sentence is included on the line.
 
 John, who lives in Wolverhampton, which is a town in the West Midlands, went home.
 '''
-import spaces
+
 import re
 import sys
 import torch
@@ -58,7 +58,6 @@ import spacy_alignments as tokenizations
 import xml.dom.minidom
 import pandas as pd
 import gradio as gr
-import os
 
 from collections import deque  #   add this at the top of app.py if not already there
 
@@ -66,11 +65,6 @@ seen = set()
 
 import io
 
-hf_token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-print("Device:", device)
-
 # Fix for Windows Unicode printing issues
 if sys.platform == "win32":
     sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
@@ -85,39 +79,46 @@ nlp = spacy.load("en_core_web_sm")  # Assuming this is used; load once
 device = "cuda" if torch.cuda.is_available() else "cpu"
 
 sign_tagging_model_name = "RJ3vans/SignTagger"
-SignTaggingTokenizer = AutoTokenizer.from_pretrained(sign_tagging_model_name, token=hf_token)
+SignTaggingTokenizer = AutoTokenizer.from_pretrained(sign_tagging_model_name)
 SignTaggingModel = AutoModelForTokenClassification.from_pretrained(
-    sign_tagging_model_name, token=hf_token
+    sign_tagging_model_name
 ).to(device)
-SignTaggingModel.eval()
 
 ssccv_span_tagging_model_name = "RJ3vans/SSCCVspanTagger"
-SSCCVspanTaggingTokenizer = AutoTokenizer.from_pretrained(ssccv_span_tagging_model_name, token=hf_token)
+SSCCVspanTaggingTokenizer = AutoTokenizer.from_pretrained(ssccv_span_tagging_model_name)
 SSCCVspanTaggingModel = AutoModelForTokenClassification.from_pretrained(
-    ssccv_span_tagging_model_name, token=hf_token
+    ssccv_span_tagging_model_name
+).to(device)
+
+ssmn_span_tagging_model_name = "RJ3vans/SSMNspanTagger"
+SSMNspanTaggingTokenizer = AutoTokenizer.from_pretrained(ssmn_span_tagging_model_name)
+SSMNspanTaggingModel = AutoModelForTokenClassification.from_pretrained(
+    ssmn_span_tagging_model_name
 ).to(device)
-SSCCVspanTaggingModel.eval()
 
 ccv_span_tagging_model_name = "RJ3vans/CCVspanTagger"
-CCVspanTaggingTokenizer = AutoTokenizer.from_pretrained(ccv_span_tagging_model_name, token=hf_token)
+CCVspanTaggingTokenizer = AutoTokenizer.from_pretrained(ccv_span_tagging_model_name)
 CCVspanTaggingModel = AutoModelForTokenClassification.from_pretrained(
-    ccv_span_tagging_model_name, token=hf_token
+    ccv_span_tagging_model_name
 ).to(device)
-CCVspanTaggingModel.eval()
 
 cmv1_span_tagging_model_name = "RJ3vans/CMV1spanTagger"
-CMV1spanTaggingTokenizer = AutoTokenizer.from_pretrained(cmv1_span_tagging_model_name, token=hf_token)
+CMV1spanTaggingTokenizer = AutoTokenizer.from_pretrained(cmv1_span_tagging_model_name)
 CMV1spanTaggingModel = AutoModelForTokenClassification.from_pretrained(
-    cmv1_span_tagging_model_name, token=hf_token
+    cmv1_span_tagging_model_name
 ).to(device)
-CMV1spanTaggingModel.eval()
 
 cmn1_span_tagging_model_name = "RJ3vans/CMN1spanTagger"
-CMN1spanTaggingTokenizer = AutoTokenizer.from_pretrained(cmn1_span_tagging_model_name, token=hf_token)
+CMN1spanTaggingTokenizer = AutoTokenizer.from_pretrained(cmn1_span_tagging_model_name)
 CMN1spanTaggingModel = AutoModelForTokenClassification.from_pretrained(
-    cmn1_span_tagging_model_name, token=hf_token
+    cmn1_span_tagging_model_name
+).to(device)
+
+cln_span_tagging_model_name = "RJ3vans/CLNspanTagger"
+CLNspanTaggingTokenizer = AutoTokenizer.from_pretrained(cmn1_span_tagging_model_name)
+CLNspanTaggingModel = AutoModelForTokenClassification.from_pretrained(
+    cln_span_tagging_model_name
 ).to(device)
-CMN1spanTaggingModel.eval()
 
 # Define label lists (extracted from notebook summary; expand with full 70+ if needed)
 sign_label_list = [
@@ -265,6 +266,17 @@ SSCCVspan_label_list = [
     "UNKNOWN",
 ]
 
+SSMNspan_label_list = [
+    "AFTER_COMPLEX_NP",
+    "BEFORE_COMPLEX_NP",
+    "ERROR",
+    "IN_COMPLEX_NP",
+    "IN_COMPLEX_NP_AFTERSIGN",
+    "IN_COMPLEX_NP_BEFORESIGN",
+    "UNKNOWN",
+]
+
+
 CCVspan_label_list = [
     "AFTER_COMPOUND",
     "BEFORE_COMPOUND",
@@ -295,8 +307,19 @@ CMN1span_label_list = [
     "UNKNOWN",
 ]
 
+CLNspan_label_list = [
+    "AFTER_COMPOUND",
+    "BEFORE_COMPOUND",
+    "IN_COMPOUND",
+    "IN_COMPOUND_AFTERSIGN",
+    "IN_COMPOUND_BEFORESIGN",
+    "NOT_NOUN_COORDINATOR",
+    "UNKNOWN",
+]
+
 required_sign_tags = [
     "M:Y_SSCCV",
+    "M:Y_SSMN",
     "M:Y_CCV",
     "M:Y_CMV1",
     "M:Y_CMP",
@@ -592,6 +615,41 @@ def improve_predicted_tag_sequence(predictions):
 
 ###############################################################################
 
+###############################################################################
+def indefinite_article_for(word: str) -> str:
+    """Choose a/an from the following orthographic word."""
+    if not word:
+        return "a"
+    w = re.sub(r"[^A-Za-z]", "", word).lower()
+    if not w:
+        return "a"
+    # simple orthographic rule (good enough for lecturer, hour, university, …)
+    if w[0] in "aeiou":
+        return "an"
+    return "a"
+###############################################################################
+
+###############################################################################
+def make_indefinite_np(np_text: str) -> str:
+    """
+    the famous lecturer  → a famous lecturer
+    an old friend        → an old friend (unchanged)
+    famous lecturer      → a famous lecturer  (if bare, add article)
+    """
+    np_text = re.sub(r"\s+", " ", (np_text or "")).strip()
+    if not np_text:
+        return np_text
+
+    m = re.match(r"^(the|a|an)\s+(.*)$", np_text, flags=re.I)
+    if m:
+        rest = m.group(2).strip()
+        first = rest.split()[0] if rest else ""
+        return f"{indefinite_article_for(first)} {rest}".strip()
+
+    first = np_text.split()[0]
+    return f"{indefinite_article_for(first)} {np_text}".strip()
+###############################################################################
+
 
 ###############################################################################
 def tag_SSCCV_span(sentence):
@@ -601,9 +659,9 @@ def tag_SSCCV_span(sentence):
     tokens = SSCCVspanTaggingTokenizer.tokenize(
         SSCCVspanTaggingTokenizer.decode(SSCCVspanTaggingTokenizer.encode(sentence))
     )
-    inputs = SSCCVspanTaggingTokenizer.encode(sentence, return_tensors="pt").to(device)
-    with torch.no_grad():
-        outputs = SSCCVspanTaggingModel(inputs)[0]
+    inputs = SSCCVspanTaggingTokenizer.encode(sentence, return_tensors="pt")
+
+    outputs = SSCCVspanTaggingModel(inputs)[0]
     predictions = torch.argmax(outputs, dim=2)
 
     SSCCV_span_tagged_tokens = [
@@ -660,6 +718,58 @@ def tag_SSCCV_span(sentence):
 
 ###############################################################################
 
+###############################################################################
+def tag_SSMN_span(sentence):
+    """
+    sentence must contain the left appositive boundary in brackets, e.g.:
+      John[,] the famous teacher, went home.
+    """
+    if re.search(r"\[\:\]\s*$", sentence):
+        sentence = sentence + " blah blah blah."
+
+    tokens = SSMNspanTaggingTokenizer.tokenize(
+        SSMNspanTaggingTokenizer.decode(SSMNspanTaggingTokenizer.encode(sentence))
+    )
+    inputs = SSMNspanTaggingTokenizer.encode(sentence, return_tensors="pt")
+    if device != "cpu":
+        inputs = inputs.to(device)
+
+    with torch.no_grad():
+        outputs = SSMNspanTaggingModel(inputs)[0]
+    predictions = torch.argmax(outputs, dim=2)
+
+    ssmn_span_tagged_predictions = [
+        SSMNspan_label_list[prediction]
+        for prediction in predictions[0].tolist()
+    ]
+
+    aligned_tokens, aligned_predictions = [], []
+    aligned_pos_tags, aligned_lemmas = [], []
+
+    sc_sentence = (
+        clean_for_spaCy(sentence) if "[" in sentence and "]" in sentence else sentence
+    )
+    doc = nlp(sc_sentence)
+    spacy_pos_tags = [t.tag_ for t in doc]
+    spacy_tokens = [t.text for t in doc]
+    spacy_lemmas = [t.lemma_ for t in doc]
+
+    a2b, b2a = tokenizations.get_alignments(spacy_tokens, tokens)
+
+    for i in range(len(spacy_tokens)):
+        for j in a2b[i]:
+            if j < len(ssmn_span_tagged_predictions):
+                aligned_tokens.append(spacy_tokens[i])
+                aligned_pos_tags.append(spacy_pos_tags[i])
+                aligned_lemmas.append(spacy_lemmas[i])
+                aligned_predictions.append(ssmn_span_tagged_predictions[j])
+            break
+
+    return sign_cleaning(
+        aligned_tokens, aligned_pos_tags, aligned_lemmas, aligned_predictions
+    )
+###############################################################################
+
 
 ###############################################################################
 def tag_CCV_span(sentence):
@@ -669,9 +779,9 @@ def tag_CCV_span(sentence):
     tokens = CCVspanTaggingTokenizer.tokenize(
         CCVspanTaggingTokenizer.decode(CCVspanTaggingTokenizer.encode(sentence))
     )
-    inputs = CCVspanTaggingTokenizer.encode(sentence, return_tensors="pt").to(device)
-    with torch.no_grad():
-        outputs = CCVspanTaggingModel(inputs)[0]
+    inputs = CCVspanTaggingTokenizer.encode(sentence, return_tensors="pt")
+
+    outputs = CCVspanTaggingModel(inputs)[0]
     predictions = torch.argmax(outputs, dim=2)
 
     CCV_span_tagged_tokens = [
@@ -731,9 +841,9 @@ def tag_CMV1_span(sentence):
     tokens = CMV1spanTaggingTokenizer.tokenize(
         CMV1spanTaggingTokenizer.decode(CMV1spanTaggingTokenizer.encode(sentence))
     )
-    inputs = CMV1spanTaggingTokenizer.encode(sentence, return_tensors="pt").to(device)
-    with torch.no_grad():
-        outputs = CMV1spanTaggingModel(inputs)[0]
+    inputs = CMV1spanTaggingTokenizer.encode(sentence, return_tensors="pt")
+
+    outputs = CMV1spanTaggingModel(inputs)[0]
     predictions = torch.argmax(outputs, dim=2)
 
     CMV1_span_tagged_tokens = [
@@ -793,9 +903,9 @@ def tag_CMN1_span(sentence):
     tokens = CMN1spanTaggingTokenizer.tokenize(
         CMN1spanTaggingTokenizer.decode(CMN1spanTaggingTokenizer.encode(sentence))
     )
-    inputs = CMN1spanTaggingTokenizer.encode(sentence, return_tensors="pt").to(device)
-    with torch.no_grad():
-        outputs = CMN1spanTaggingModel(inputs)[0]
+    inputs = CMN1spanTaggingTokenizer.encode(sentence, return_tensors="pt")
+
+    outputs = CMN1spanTaggingModel(inputs)[0]
     predictions = torch.argmax(outputs, dim=2)
 
     CMN1_span_tagged_tokens = [
@@ -845,6 +955,68 @@ def tag_CMN1_span(sentence):
     )  #   added return
 
 
+###############################################################################
+
+###############################################################################
+def tag_CLN_span(sentence):
+    if re.search("\[\:\]\s*$", sentence):
+        sentence = sentence + " blah blah blah."
+
+    tokens = CLNspanTaggingTokenizer.tokenize(
+        CLNspanTaggingTokenizer.decode(CLNspanTaggingTokenizer.encode(sentence))
+    )
+    inputs = CLNspanTaggingTokenizer.encode(sentence, return_tensors="pt")
+
+    outputs = CLNspanTaggingModel(inputs)[0]
+    predictions = torch.argmax(outputs, dim=2)
+
+    CLN_span_tagged_tokens = [
+        (token, CLNspan_label_list[prediction])
+        for token, prediction in zip(tokens, predictions[0].tolist())
+    ]
+
+    CLN_span_tagged_predictions = [p for t, p in CLN_span_tagged_tokens]
+
+    aligned_tokens = []
+    aligned_predictions = []
+    aligned_pos_tags = []
+    aligned_lemmas = []
+
+    sc_sentence = (
+        clean_for_spaCy(sentence) if "[" in sentence and "]" in sentence else sentence
+    )
+    doc = nlp(sc_sentence)
+    spacy_pos_tags = [t.tag_ for t in doc]
+    spacy_tokens = [t.text for t in doc]
+    spacy_lemmas = [t.lemma_ for t in doc]
+
+    a2b, b2a = tokenizations.get_alignments(spacy_tokens, tokens)
+
+    for i in range(len(spacy_tokens)):
+        for j in a2b[i]:
+            aligned_tokens.append(spacy_tokens[i])
+            aligned_pos_tags.append(spacy_pos_tags[i])
+            aligned_lemmas.append(spacy_lemmas[i])
+            aligned_predictions.append(CLN_span_tagged_predictions[j])
+            break
+
+    clean_tokens, clean_pos_tags, clean_lemmas, clean_predictions = sign_cleaning(
+        aligned_tokens, aligned_pos_tags, aligned_lemmas, aligned_predictions
+    )
+
+    simplifiable = all("COMPOUND" in p for p in clean_predictions)
+
+    if not simplifiable:
+        True  # placeholder for future logic
+
+    return (
+        clean_tokens,
+        clean_pos_tags,
+        clean_lemmas,
+        clean_predictions,
+    )  #   added return
+
+
 ###############################################################################
 
 ###############################################################################
@@ -884,9 +1056,9 @@ def tag_all_signs_in_sent(sent):
     tokens = SignTaggingTokenizer.tokenize(
         SignTaggingTokenizer.decode(SignTaggingTokenizer.encode(sent))
     )
-    inputs = SignTaggingTokenizer.encode(sent, return_tensors="pt").to(device)
-    with torch.no_grad():
-        outputs = SignTaggingModel(inputs)[0]
+    inputs = SignTaggingTokenizer.encode(sent, return_tensors="pt")
+
+    outputs = SignTaggingModel(inputs)[0]
     predictions = torch.argmax(outputs, dim=2)
 
     sign_tagged_tokens = [
@@ -1205,7 +1377,96 @@ def SSCCVsimplify(xml_sent):
 
     return simplification
 
+###############################################################################
+
+###############################################################################
+def looks_like_proper_name_np(np_text: str) -> bool:
+    toks = np_text.split()
+    return bool(toks) and all(t[:1].isupper() for t in toks if t.isalpha())
+###############################################################################
+
+###############################################################################
+def SSMNsimplify(xml_sent):
+    """
+    Appositive / non-finite nominal modifier (SSMN):
+
+      John Smith, the famous lecturer, went home.
+        → John Smith went home.
+        → John Smith is a famous lecturer.
+    """
+    simplification = []
+
+    try:
+        if xml_sent.attrib.get("TYPE") not in ("COMPLEX_NP", "APPOSITIVE", "SSMN"):
+            # still try if elements exist
+            pass
+
+        def elem_text(elem):
+            if elem is None:
+                return ""
+            parts = []
+            for w in elem.findall("W"):
+                if not w.text:
+                    continue
+                t = str(w.text).strip()
+                t = re.sub(r"[\[\]]+", "", t)
+                if t:
+                    parts.append(t)
+            return " ".join(parts).strip()
+
+        def strip_edge_commas(s: str) -> str:
+            s = re.sub(r"\s+", " ", (s or "")).strip()
+            s = re.sub(r"^[,;:\s]+", "", s)
+            s = re.sub(r"[,;:\s]+$", "", s)
+            return s.strip()
+
+        def tidy_sent(s: str) -> str:
+            s = re.sub(r"\s+", " ", (s or "")).strip()
+            s = re.sub(r"\s+([.,!?;:])", r"\1", s)
+            s = re.sub(r"([.,!?;:])\s+", r"\1 ", s)
+            s = re.sub(r",+\s*\.", ".", s)
+            if s and not s.endswith((".", "!", "?")):
+                s += "."
+            if s:
+                s = s[0].upper() + s[1:]
+            return s
+
+        before = elem_text(xml_sent.find(".//BEFORE_COMPLEX_CONSTITUENT"))
+        head = elem_text(xml_sent.find(".//IN_COMPLEX_CONSTITUENT_BEFORESIGN"))
+        # trigger comma lives in IN_COMPLEX_CONSTITUENT — discarded
+        appositive = elem_text(xml_sent.find(".//IN_COMPLEX_CONSTITUENT_AFTERSIGN"))
+        after = elem_text(xml_sent.find(".//AFTER_COMPLEX_CONSTITUENT"))
+
+        head = strip_edge_commas(head)
+        appositive = strip_edge_commas(appositive)
+        before = strip_edge_commas(before)
+        after = strip_edge_commas(after)
+
+        if not head:
+            return []
+
+        # 1) Matrix clause without appositive
+        matrix = " ".join(x for x in [before, head, after] if x).strip()
+        matrix = tidy_sent(matrix)
 
+        # 2) Equative: Head is a/an …
+        if looks_like_proper_name_np(appositive):
+            pred_np = appositive
+        else:
+            pred_np = make_indefinite_np(appositive)
+        equative = tidy_sent(f"{head} is {pred_np}")
+
+        if matrix:
+            simplification.append(matrix)
+        if equative and equative != matrix:
+            simplification.append(equative)
+
+        print(f"SSMNsimplify produced {len(simplification)} sentences: {simplification}")
+        return simplification
+
+    except Exception as e:
+        print(f"SSMNsimplify error: {e}")
+        return []
 ###############################################################################
 
 ###############################################################################
@@ -1257,6 +1518,111 @@ def rewrite_residual_list_comma(sent, coordinator="and"):
     return out
 ###############################################################################
 
+###############################################################################
+def _singular_present_form(lemma: str) -> str:
+    """Map verb lemma → 3rd person singular present."""
+    lemma = (lemma or "").lower()
+    irregular = {
+        "be": "is",
+        "have": "has",
+        "do": "does",
+        "go": "goes",
+        "say": "says",
+    }
+    if lemma in irregular:
+        return irregular[lemma]
+    if lemma.endswith(("s", "sh", "ch", "x", "z", "o")):
+        return lemma + "es"
+    if len(lemma) > 1 and lemma.endswith("y") and lemma[-2] not in "aeiou":
+        return lemma[:-1] + "ies"
+    return lemma + "s"
+
+
+def subject_is_singular(subj_token) -> bool:
+    """True if the nominal subject should take singular agreement."""
+    # Coordinated subjects → plural
+    if any(c.dep_ == "cc" for c in subj_token.subtree):
+        return False
+    # Explicit plural morph / tags
+    num = subj_token.morph.get("Number")
+    if num == ["Plur"]:
+        return False
+    if num == ["Sing"]:
+        return True
+    if subj_token.tag_ in ("NNS", "NNPS", "PRP") and subj_token.lower_ in {
+        "we", "they", "you", "i"
+    }:
+        # I/you are special; treat as not 3sg
+        return False
+    if subj_token.tag_ in ("NNS", "NNPS"):
+        return False
+    if subj_token.lower_ in {"i", "you", "we", "they"}:
+        return False
+    # he/she/it / singular NN/NNP / this/that
+    if subj_token.lower_ in {"he", "she", "it", "this", "that"}:
+        return True
+    if subj_token.tag_ in ("NN", "NNP", "DT", "PRP$"):
+        return True
+    # fallback: whole subject span text
+    text = " ".join(t.text for t in subj_token.subtree).lower()
+    if " and " in text:
+        return False
+    return True
+
+
+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.
+    """
+    if not sent or not sent.strip():
+        return sent
+
+    doc = nlp(sent)
+    edits = []  # (token.i, new_text)
+
+    for tok in doc:
+        if tok.dep_ != "ROOT" and tok.dep_ not in ("ccomp", "xcomp", "advcl"):
+            # Prefer sentence ROOT finite verb
+            pass
+
+    roots = [t for t in doc if t.dep_ == "ROOT"]
+    if not roots:
+        return sent
+    verb = roots[0]
+
+    # Only repair untreated present plural / base used as present
+    if verb.tag_ not in ("VBP", "VB"):
+        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:
+        return sent
+    subj = subjs[0]
+
+    if not subject_is_singular(subj):
+        return sent
+
+    lemma = verb.lemma_.lower()
+    new_form = _singular_present_form(lemma)
+
+    # Preserve capitalisation
+    if verb.text and verb.text[0].isupper():
+        new_form = new_form[0].upper() + new_form[1:]
+
+    if new_form == verb.text:
+        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()
+###############################################################################
+
 ###############################################################################
 def CompoundSimplify(xml_sent):
     """
@@ -1322,25 +1688,27 @@ def CompoundSimplify(xml_sent):
             x for x in [before_text, aftersign_text, after_text] if x
         ).strip()
 
+
         def tidy(s):
+            if not s:
+                return ""
+            s = str(s)
             s = re.sub(r"\s+", " ", s).strip()
             s = re.sub(r"\s+([.,!?;:])", r"\1", s)
             s = re.sub(r"([.,!?;:])\s+", r"\1 ", s)
-
             # decimals: 8 . 2 → 8.2
             s = re.sub(r"(\d)\s*\.\s*(\d)", r"\1.\2", s)
-
-            # list-coordinator debris: "43;." / "43,." / "43;;." → "43."
+            # list debris only at the end / before final period
             s = re.sub(r"[,;:]+\s*\.", ".", s)
-            # dangling separators at end before a period is added
             s = re.sub(r"[,;:]+\s*$", "", s)
-
+            s = s.strip()
             if s and not s.endswith((".", "!", "?")):
                 s += "."
             if s:
                 s = s[0].upper() + s[1:]
             return s
-        
+
+
 
         sent1 = tidy(sent1)
         sent2 = tidy(sent2)
@@ -1397,7 +1765,26 @@ def create_xml_sent(tokens, pos_tags, lemmas, predictions, sign_tag):
         )
         after_complex_constituent = ET.SubElement(xml_sent, "AFTER_COMPLEX_CONSTITUENT")
 
-    elif sign_tag in ["M:Y_CCV", "M:Y_CMV1", "M:Y_CMN1"]:
+    elif sign_tag in ["M:Y_SSMN"]:  # SSMA later if you want ages
+        xml_sent.set("TYPE", "COMPLEX_NP")  # or "APPOSITIVE"
+        before_complex_constituent = ET.SubElement(
+            xml_sent, "BEFORE_COMPLEX_CONSTITUENT"
+        )
+        in_complex_constituent_beforesign = ET.SubElement(
+            xml_sent, "IN_COMPLEX_CONSTITUENT_BEFORESIGN"
+        )
+        in_complex_constituent = ET.SubElement(
+            xml_sent, "IN_COMPLEX_CONSTITUENT"
+        )
+        in_complex_constituent_aftersign = ET.SubElement(
+            xml_sent, "IN_COMPLEX_CONSTITUENT_AFTERSIGN"
+        )
+        after_complex_constituent = ET.SubElement(
+            xml_sent, "AFTER_COMPLEX_CONSTITUENT"
+        )
+        
+    elif sign_tag in ["M:Y_CCV", "M:Y_CMV1", "M:Y_CMN1", "M:Y_CLN"]:
+        xml_sent.set("TYPE", "COMPOUND")
         before_complex_constituent = ET.SubElement(
             xml_sent, "BEFORE_COMPOUND_CONSTITUENT"
         )
@@ -1452,6 +1839,17 @@ def create_xml_sent(tokens, pos_tags, lemmas, predictions, sign_tag):
                 word.attrib["POS"] = pos_tags[x]
                 word.attrib["LEMMA"] = lemmas[x]
 
+        elif (
+            "NOT_NOUN_COORDINATOR" in predictions[x]
+            or "NOT_NP_COORDINATOR" in predictions[x]
+            or "NOT_CLAUSE_COORDINATOR" in predictions[x]
+            or "NOT_VP_COORDINATOR" in predictions[x]
+        ):
+            word = ET.SubElement(in_complex_constituent_beforesign, "W")
+            word.text = tokens[x]
+            word.attrib["POS"] = pos_tags[x]
+            word.attrib["LEMMA"] = lemmas[x]
+                
         elif "IN_" in predictions[x]:
             word = ET.SubElement(in_complex_constituent, "W")
             word.text = tokens[x]
@@ -1470,6 +1868,8 @@ def create_xml_sent(tokens, pos_tags, lemmas, predictions, sign_tag):
             word.attrib["POS"] = pos_tags[x]
             word.attrib["LEMMA"] = lemmas[x]
 
+
+
         x += 1
 
     # Print the XML (as you requested)
@@ -1489,6 +1889,8 @@ def get_COMPLEX_NP_type(xml_sent):
     final_iccb_pos_tag = "UNKNOWN"
 
     punct = re.compile(r"^[\,\:\;]$")
+    VERB_TAGS = ["VB", "VBD", "VBG", "VBN", "VBZ", "VBP", "MD"]
+    NOMINAL_TAGS = ["NNP", "NNPS", "NN", "NNS", "DT", "CD", "PRP", "PRP$"]
 
     for el in xml_sent:
         if el.tag == "IN_COMPLEX_CONSTITUENT_AFTERSIGN":
@@ -1498,7 +1900,11 @@ def get_COMPLEX_NP_type(xml_sent):
                     if w.text and not punct.match(w.text.strip()):
                         first_icca_pos_tag = w.attrib.get("POS", "UNKNOWN")
                         break
-                final_icca_pos_tag = el[-1].attrib["POS"]
+                # last *content* token, not a trailing comma
+                for w in reversed(list(el)):
+                    if w.text and not punct.match(w.text.strip()):
+                        final_icca_pos_tag = w.attrib.get("POS", "UNKNOWN")
+                        break
             except Exception:
                 pass
 
@@ -1514,15 +1920,9 @@ def get_COMPLEX_NP_type(xml_sent):
 
     if final_iccb_pos_tag in ["IN"]:
         complex_NP_type = "PREPOSITION_OBJECT_RELATIVISED"
-    elif first_icca_pos_tag in [
-        "NNP",
-        "NNPS",
-        "NN",
-        "DT",
-        "CD",
-    ] and final_icca_pos_tag in ["VB", "VBD", "VBG", "VBN", "VBZ"]:
+    elif first_icca_pos_tag in NOMINAL_TAGS and final_icca_pos_tag in VERB_TAGS:
         complex_NP_type = "VERB_OBJECT_RELATIVISED"
-    elif first_icca_pos_tag in ["VB", "VBD", "VBG", "VBN", "VBZ"]:
+    elif first_icca_pos_tag in VERB_TAGS:
         complex_NP_type = "SUBJECT_RELATIVISED"
 
     return complex_NP_type
@@ -1633,12 +2033,14 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
     mode = "ccv"   → bracket only the rightmost CCV sign
     mode = "cmv1"  → bracket only the rightmost CMV1 sign
     mode = "cmn1"  → bracket only the rightmost CMN1 sign
+    mode = "cln"  → bracket only the rightmost CLN sign
     mode = "ssccv" → bracket one relative SSCCV trigger:
                      - nested relatives (2+ opens before next ESCCV): innermost
                        (rightmost preferred trigger before that ESCCV)
                      - coordinated relatives (CCV between opens): leftmost
                      - otherwise: leftmost relative trigger
                      - fallback: leftmost SSCCV/ESCCV (e.g. bare "that")
+    mode = "ssmn"  → bracket only the leftmost SSMN sign
     """
 
     def surface_of(item):
@@ -1652,8 +2054,10 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
     ccv_indices = []
     cmv1_indices = []
     cmn1_indices = []
+    cln_indices = []
     ssccv_indices = []
     esccv_indices = []
+    ssmn_indices = []
 
     for i, item in enumerate(tagged_list):
         s = str(item)
@@ -1663,13 +2067,17 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
             cmv1_indices.append(i)
         if "<M:Y_CMN1>" in s or "M:Y_CMN1" in s:
             cmn1_indices.append(i)
+        if "<M:Y_CLN>" in s or "M:Y_CLN" in s:
+            cln_indices.append(i)
         if "M:Y_SSCCV" in s:
             ssccv_indices.append(i)
         if "M:Y_ESCCV" in s:
             esccv_indices.append(i)
             if i not in ssccv_indices:
                 ssccv_indices.append(i)
-
+        if "M:Y_SSMN" in s:
+            ssmn_indices.append(i)
+                
     target = set()
 
     if mode == "ccv" and ccv_indices:
@@ -1681,6 +2089,12 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
     elif mode == "cmn1" and cmn1_indices:
         target.add(cmn1_indices[-1])
 
+    elif mode == "cln" and cln_indices:
+        target.add(cln_indices[-1])
+
+    elif mode == "ssmn" and ssmn_indices:
+        target.add(ssmn_indices[0])  # leftmost appositive boundary
+        
     elif mode == "ssccv" and ssccv_indices:
         relative_pronouns = {"who", "which", "whom", "whose"}
         preferred = []
@@ -1767,7 +2181,6 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
 
 
 ###############################################################################
-@spaces.GPU(duration=120)
 def process_text(input_text):
     print("=== ITERATIVE SIMPLIFICATION (priority + clean tokens) ===")
     try:
@@ -1858,6 +2271,10 @@ def process_text(input_text):
                         any(x in t for x in ["M:Y_SSCCV", "M:Y_ESCCV"])
                         for t in tagged_list
                     )
+                    has_ssmn = any(
+                        any(x in t for x in ["M:Y_SSMN", "M:Y_ESMN"])
+                        for t in tagged_list
+                    )
                     has_ccv = any(
                         "<M:Y_CCV>" in t or "M:Y_CCV" in t for t in tagged_list
                     )
@@ -1867,12 +2284,20 @@ def process_text(input_text):
                     has_cmn1 = any(
                         "<M:Y_CMN1>" in t or "M:Y_CMN1" in t for t in tagged_list
                     )
+                    has_cln = any(
+                        "<M:Y_CLN>" in t or "M:Y_CLN" in t for t in tagged_list
+                    )
 
                     if has_ssccv:
                         mode = "ssccv"
                         xml_tag = "M:Y_SSCCV"
                         simplifier = SSCCVsimplify
                         span_fn = tag_SSCCV_span
+                    elif has_ssmn:
+                        mode = "ssmn"
+                        xml_tag = "M:Y_SSMN"
+                        simplifier = SSMNsimplify
+                        span_fn = tag_SSMN_span
                     elif has_ccv:
                         mode = "ccv"
                         xml_tag = "M:Y_CCV"
@@ -1888,6 +2313,11 @@ def process_text(input_text):
                         xml_tag = "M:Y_CMN1"
                         simplifier = CompoundSimplify
                         span_fn = tag_CMN1_span
+                    elif has_cln:
+                        mode = "cln"
+                        xml_tag = "M:Y_CLN"
+                        simplifier = CompoundSimplify
+                        span_fn = tag_CLN_span
                     else:
                         sentence_final.append(current)
                         continue
@@ -1922,11 +2352,12 @@ def process_text(input_text):
                     )
                     simps = simplifier(xml_sent)
 
-                    # Residual comma → same conjunction (CCV / CMV1 / CMN1 only)
+                    # Residual comma → same conjunction (CCV / CMV1 / CMN1 / CLN only)
                     if (
                         simps
                         and simplifier is CompoundSimplify
-                        and xml_tag in ("M:Y_CCV", "M:Y_CMV1", "M:Y_CMN1")
+                        and xml_tag
+                        in ("M:Y_CCV", "M:Y_CMV1", "M:Y_CMN1", "M:Y_CLN")
                     ):
                         coord = extract_coordinator_from_xml(xml_sent)
                         if coord:
@@ -1940,7 +2371,17 @@ def process_text(input_text):
                                     )
                                 rewritten.append(s2)
                             simps = rewritten
-                    
+
+                    # 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
+
                     if not simps:
                         print(
                             "Simplifier returned []; forcing final (no re-queue)"
@@ -1975,14 +2416,12 @@ def process_text(input_text):
                     if not queued_any:
                         sentence_final.append(current)
 
-                # ★ CHANGE 1: order this original sentence's finals
                 for s in order_sentences_for_discourse(sentence_final):
                     s = clean_output(s)
                     if s:
                         para_simplified.append(s)
 
             if para_simplified:
-                # ★ CHANGE 2 (optional): order whole paragraph
                 para_simplified = order_sentences_for_discourse(para_simplified)
                 output_paragraphs.append(" ".join(para_simplified))
 
@@ -2043,107 +2482,52 @@ custom_css = """
 }
 """
 
-with gr.Blocks(title="Syntactic Sentence Simplifier") as demo:
+with gr.Blocks(
+    title="Syntactic Sentence Simplifier",
+    css=custom_css,
+) as demo:
     gr.Markdown("# Syntactic Sentence Simplifier")
     gr.Markdown(
-        """
-This demo simplifies sentences containing compound constituents:
-
-* *clauses*
-* *verb phrases*
-* *noun phrases*
-
-and complex noun phrases modified by:
-
-* *nominally bound non-restrictive finite relative clauses (subject relativised and verb/preposition object relativised)*
-
-Paste text, or click examples to **add** them into the box below
-(you can edit the text afterwards).
-"""
+        "Paste or type your text below. Uses Hugging Face models + simplification logic."
     )
 
-
-    # 1) Complex input
     input_text = gr.Textbox(
-        lines=12,
+        lines=10,
         label="Original text",
-        placeholder="Paste your text here, or add examples below...",
+        placeholder="Paste your text here...",
         elem_classes=["input-text"],
     )
 
-    # 2) Bridge button (directly under input)
-    btn = gr.Button("Process & Simplify", variant="primary")
-
-    # 3) Simple output
     output_text = gr.Textbox(
-        lines=12,
+        lines=10,
         label="Simplified text",
         elem_classes=["output-text"],
     )
 
-    btn.click(fn=process_text, inputs=input_text, outputs=output_text)
-
-    # Examples / clear (under the whole stack, or under input if you prefer)
-    EXAMPLE_SENTENCES = [
-        "John kicked the ball and walked to Leeds.",
-        "John bought two apples and three oranges.",
-        "John left early and Mary stayed late.",
-        "John, who lives in London, went home.",
-        "Peter, who Sam likes, went home.",
-        "Fred bought a computer and a printer and switched them on.",
-        "Fred bought a computer and a printer, and Mary bought a PS5.",
-        "Mary, who lives in London, went home, and Peter stayed.",
-        "John, who kicked the ball and walked away, went home.",
-        "John, who bought a computer and a printer, went home.",
-        "John, who Steven tolerated and who mary despised, went home.",
-        "John, who lives in Shifnal, which is a town in the Black Country, went home.",
-        "Mary, who lives in London, kicked the ball and walked to Leeds, and John stayed home.",
-        "Jackie, who lives in Manchester, bought a computer and a monitor, and Fred bought bread.",
-        "Count Binface bought two apples and three pears and ate them, and Nigel left.",
-        "Count Binface, who bought two apples and three pears and ate them, went home.",
-        "Hadric Wode, who bought a mace and a shield and used them, left early, and Fenric, who was tired, stayed home.",
-        "John is one candidate, Mary ignores signals, and Bill eats grass.",
-        "John went to Essex, Bill set out for Sussex, and Mary returned from Halifax.",
-        "Joshua told me that John, who lives in New York, is going to London, Jack loves Norwich, and Mary, who is extremely confident, adores Milton Keynes, just as Fred predicted.",
-        "John kicked the ball and walked to Leeds, and Peter stayed home.",
-        "John is one test, Mary, who lives in London, loves exams, and Bill eats bread.",
-        "John went to Wolverhampton, Bill set out for Coventry, and Mary returned from Birmingham.",
-        "John, who lives in London, is going to Wolverhampton, and Mary, who is a bit nervous, adores Birmingham.",
-        "John kicked the ball and walked to Leeds. Mary bought a laptop and a mousemat.",
-        "I love France.",
-        "John met the dog, the cat, and the tortoise.",
-        "The Environment Agency said record winter rainfall had helped to replenish reservoirs and groundwater, but reservoir storage has now fallen to 7.4% below the average for this time of year.",
-    ]
+    btn = gr.Button("Process & Simplify", variant="primary")
 
-    def append_example(current_text, example):
-        example = (example or "").strip()
-        if not example:
-            return current_text or ""
-        current = (current_text or "").strip()
-        if not current:
-            return example
-        return current + "\n\n" + example
-
-    gr.Markdown("### Add an example to the box above (click to append; then edit freely)")
-
-    clear_btn = gr.Button("Clear input", size="sm")
-    clear_btn.click(fn=lambda: "", outputs=input_text)
-
-    for ex in EXAMPLE_SENTENCES:
-        label = ex if len(ex) <= 100 else ex[:97] + "..."
-        ex_btn = gr.Button(label, size="sm")
-        ex_btn.click(
-            fn=lambda current, s=ex: append_example(current, s),
-            inputs=input_text,
-            outputs=input_text,
-        )
+    btn.click(
+        fn=process_text,
+        inputs=input_text,
+        outputs=output_text,
+    )
 
-print("Gradio interface ready. Starting web server...")
+print("  Gradio interface ready. Starting web server...")
 
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        css=custom_css,   # if you use custom_css
+        debug=True,
+        share=False,
+    )
+
+
+    
+    '''
+    test = (
+        "Joshua told me that John, who lives in London, is going to Wolverhampton, Jack loves Norwich, and Mary, who is a bit nervous, adores Birmingham, just as Fred predicted."
     )
+    print(process_text(test))
+    '''