Upload hf_app_SSCCV_CCV_CMN1_CMV1.py

hf_app_SSCCV_CCV_CMN1_CMV1.py

@@ -0,0 +1,968 @@
+# app.py — Syntactic Sentence Simplifier (Hugging Face Spaces / ZeroGPU)
+# Models: SignTagger, SSCCVspanTagger, CCVspanTagger, CMV1spanTagger, CMN1spanTagger
+
+# --- ZeroGPU: import spaces BEFORE torch / transformers ---
+import spaces
+
+import os
+import re
+import sys
+from collections import deque
+
+import torch
+from transformers import AutoModelForTokenClassification, AutoTokenizer
+import spacy
+import xml.etree.ElementTree as ET
+import xml.dom.minidom
+import gradio as gr
+
+try:
+    import spacy_alignments as tokenizations
+except ImportError:
+    tokenizations = None
+
+# Optional Hub token (Space secret: HF_TOKEN)
+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(f"Device: {device} | cuda available: {torch.cuda.is_available()}")
+
+
+def _load_tok_model(name):
+    tok = AutoTokenizer.from_pretrained(name, token=hf_token)
+    model = AutoModelForTokenClassification.from_pretrained(name, token=hf_token)
+    model.to(device)
+    model.eval()
+    return tok, model
+
+
+# ---------- Models ----------
+sign_tagging_model_name = "RJ3vans/SignTagger"
+ssccv_span_tagging_model_name = "RJ3vans/SSCCVspanTagger"
+ccv_span_tagging_model_name = "RJ3vans/CCVspanTagger"
+cmv1_span_tagging_model_name = "RJ3vans/CMV1spanTagger"
+cmn1_span_tagging_model_name = "RJ3vans/CMN1spanTagger"
+
+SignTaggingTokenizer, SignTaggingModel = _load_tok_model(sign_tagging_model_name)
+SSCCVspanTaggingTokenizer, SSCCVspanTaggingModel = _load_tok_model(
+    ssccv_span_tagging_model_name
+)
+CCVspanTaggingTokenizer, CCVspanTaggingModel = _load_tok_model(
+    ccv_span_tagging_model_name
+)
+CMV1spanTaggingTokenizer, CMV1spanTaggingModel = _load_tok_model(
+    cmv1_span_tagging_model_name
+)
+CMN1spanTaggingTokenizer, CMN1spanTaggingModel = _load_tok_model(
+    cmn1_span_tagging_model_name
+)
+
+# Label lists (must match your fine-tuned models’ config.id2label order)
+sign_label_list = list(SignTaggingModel.config.id2label.values())
+SSCCVspan_label_list = list(SSCCVspanTaggingModel.config.id2label.values())
+CCVspan_label_list = list(CCVspanTaggingModel.config.id2label.values())
+CMV1span_label_list = list(CMV1spanTaggingModel.config.id2label.values())
+CMN1span_label_list = list(CMN1spanTaggingModel.config.id2label.values())
+
+# spaCy
+try:
+    nlp = spacy.load("en_core_web_sm")
+except OSError:
+    from spacy.cli import download
+
+    download("en_core_web_sm")
+    nlp = spacy.load("en_core_web_sm")
+
+print("All models loaded successfully!")
+
+# =====================================================================
+# Helpers — keep behaviour aligned with your local working app
+# =====================================================================
+
+_ANAPHORIC_PRONOUNS = {
+    "he",
+    "she",
+    "it",
+    "they",
+    "him",
+    "her",
+    "them",
+    "his",
+    "hers",
+    "its",
+    "their",
+    "theirs",
+}
+
+
+def sentence_has_anaphoric_pronoun(s: str) -> bool:
+    words = re.findall(r"[A-Za-z']+", s.lower())
+    return any(w in _ANAPHORIC_PRONOUNS for w in words)
+
+
+def order_sentences_for_discourse(sentences):
+    """Non-pronoun sentences first; pronoun-bearing last (stable)."""
+    no_pron = []
+    with_pron = []
+    for s in sentences:
+        if sentence_has_anaphoric_pronoun(s):
+            with_pron.append(s)
+        else:
+            no_pron.append(s)
+    return no_pron + with_pron
+
+
+def clean_output(s: str) -> str:
+    if not s:
+        return ""
+    s = str(s)
+    s = re.sub(r"\s*\(\s*m\s*:\s*y[^)]*\)\s*", " ", s, flags=re.I)
+    s = re.sub(r"M:Y_[A-Za-z0-9_]+", "", s, flags=re.I)
+    s = re.sub(r"##\w*", "", s)
+    s = re.sub(r"[\[\]]+", "", s)
+    s = re.sub(r"\s+", " ", s).strip()
+    s = re.sub(r"\s+([.,!?;:])", r"\1", s)
+    s = re.sub(r",+\s*\.", ".", s)
+    s = re.sub(r",+\s*$", "", s)
+    if s and not s.endswith((".", "!", "?")):
+        s += "."
+    if s:
+        s = s[0].upper() + s[1:]
+    return s
+
+
+def clean_for_spaCy(sent: str) -> str:
+    """Normalize one [...] trigger for spaCy; avoid catastrophic backtracking."""
+    if "[" not in sent or "]" not in sent:
+        return sent
+    # Prefer a simple pass-through if already well-formed
+    m = re.search(
+        r"\[(\s*[,;:]?\s*(?:and|but|or|that|what|when|where|which|while|who)"
+        r"(?:\s+(?:and|but|or|that|what|when|where|which|while|who))?)\s*\]",
+        sent,
+        flags=re.I,
+    )
+    if not m:
+        return sent
+    return sent  # bracketed form is intentional for span taggers
+
+
+def drop_bracket_tokens(tokens, pos, lemmas, preds):
+    out_t, out_p, out_l, out_pr = [], [], [], []
+    for t, p, l, pr in zip(tokens, pos, lemmas, preds):
+        if t in ("[", "]"):
+            continue
+        out_t.append(t)
+        out_p.append(p)
+        out_l.append(l)
+        out_pr.append(pr)
+    return out_t, out_p, out_l, out_pr
+
+
+def sign_cleaning(tokens, pos_tags, lemmas, predictions):
+    """Merge BPE pieces; keep lists aligned. Lightweight version."""
+    clean_tokens, clean_pos, clean_lemmas, clean_preds = [], [], [], []
+    i = 0
+    while i < len(tokens):
+        tok = tokens[i]
+        if tok.startswith("##") and clean_tokens:
+            clean_tokens[-1] = clean_tokens[-1] + tok[2:]
+        else:
+            clean_tokens.append(tok)
+            clean_pos.append(pos_tags[i] if i < len(pos_tags) else "XX")
+            clean_lemmas.append(lemmas[i] if i < len(lemmas) else tok.lower())
+            clean_preds.append(predictions[i] if i < len(predictions) else "UNKNOWN")
+        i += 1
+    return clean_tokens, clean_pos, clean_lemmas, clean_preds
+
+
+def improve_predicted_tag_sequence(preds):
+    """Map error / NOT_* labels to a neutral tag when needed."""
+    out = []
+    for p in preds:
+        p = str(p)
+        if p in (
+            "UNKNOWN",
+            "ERROR",
+            "NOT_CLAUSE_COORDINATOR",
+            "NOT_VP_COORDINATOR",
+            "NOT_NP_COORDINATOR",
+        ):
+            out.append(p)
+        else:
+            out.append(p)
+    return out
+
+
+def normalize_compound_preds(preds):
+    """Ensure compound-region labels are usable by create_xml_sent."""
+    mapped = []
+    for p in preds:
+        p = str(p)
+        p = p.replace("BEFORE_COMPOUND_CONSTITUENT", "BEFORE_COMPOUND")
+        p = p.replace("AFTER_COMPOUND_CONSTITUENT", "AFTER_COMPOUND")
+        mapped.append(p)
+    return mapped
+
+
+def tag_all_signs_in_sent(sent: str):
+    sent = re.sub(r"do not", "don't", sent, flags=re.I)
+    sent = re.sub(
+        r"\[((,|;|:|and|but|or|that|what|when|where|which|while|who)"
+        r"(_(and|but|or|that|what|when|where|which|while|who))?)\]",
+        r"\1\2",
+        sent,
+        flags=re.I,
+    )
+
+    enc = SignTaggingTokenizer.encode(sent, return_tensors="pt")
+    if hasattr(enc, "to"):
+        inputs = enc.to(device)
+    else:
+        inputs = enc
+        if torch.is_tensor(inputs):
+            inputs = inputs.to(device)
+
+    with torch.no_grad():
+        outputs = SignTaggingModel(inputs)[0]
+    predictions = torch.argmax(outputs, dim=2)
+
+    tokens = SignTaggingTokenizer.convert_ids_to_tokens(inputs[0].tolist())
+    # Drop special tokens for surface list building
+    sign_tagged_tokens = [
+        (tok, sign_label_list[pred])
+        for tok, pred in zip(tokens, predictions[0].tolist())
+    ]
+
+    print("sign_tagged_tokens:", sign_tagged_tokens)
+
+    relevant_sign_offsets = []
+    relevant_tags = []
+    for t, (tok, lab) in enumerate(sign_tagged_tokens):
+        if str(lab).startswith("M:Y"):
+            relevant_sign_offsets.append(t)
+            relevant_tags.append(lab)
+
+    tagged_sent_list = [tok for tok, _ in sign_tagged_tokens]
+    for o, rtag in zip(relevant_sign_offsets, relevant_tags):
+        tagged_sent_list[o] = f"<{rtag}>{tagged_sent_list[o]}</{rtag}>"
+
+    tagged_sent = [
+        tagged_sent_list[x]
+        for x in range(len(sign_tagged_tokens))
+        if sign_tagged_tokens[x][0] not in ("[CLS]", "[SEP]", "<s>", "</s>")
+    ]
+    print(f"Returning tagged_sent: result = {tagged_sent}")
+    return tagged_sent
+
+
+def build_single_sign_bracketed(tagged_list, mode="ccv"):
+    def surface_of(item):
+        item = str(item)
+        if item.startswith("<M:Y_") and ">" in item:
+            start = item.find(">") + 1
+            end = item.rfind("<")
+            if end > start:
+                return item[start:end]
+        return item
+
+    ccv_indices, cmv1_indices, cmn1_indices = [], [], []
+    ssccv_indices, esccv_indices = [], []
+
+    for i, item in enumerate(tagged_list):
+        s = str(item)
+        if "M:Y_CCV" in s:
+            ccv_indices.append(i)
+        if "M:Y_CMV1" in s:
+            cmv1_indices.append(i)
+        if "M:Y_CMN1" in s:
+            cmn1_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)
+
+    target = set()
+    if mode == "ccv" and ccv_indices:
+        target.add(ccv_indices[-1])
+    elif mode == "cmv1" and cmv1_indices:
+        target.add(cmv1_indices[-1])
+    elif mode == "cmn1" and cmn1_indices:
+        target.add(cmn1_indices[-1])
+    elif mode == "ssccv" and ssccv_indices:
+        relative_pronouns = {"who", "which", "whom", "whose"}
+        preferred = []
+        for i in ssccv_indices:
+            surface = surface_of(tagged_list[i]).strip().lower()
+            if surface in relative_pronouns:
+                preferred.append(i)
+                continue
+            if surface in {",", ";", ":"} and i + 1 < len(tagged_list):
+                nxt = surface_of(tagged_list[i + 1]).strip().lower()
+                if nxt in relative_pronouns or nxt == "that":
+                    preferred.append(i)
+        if preferred:
+            nested = coordinated = False
+            if esccv_indices:
+                first_es = min(esccv_indices)
+                opens_before_close = [i for i in preferred if i < first_es]
+                if len(opens_before_close) >= 2:
+                    first_open, last_open = opens_before_close[0], opens_before_close[-1]
+                    ccv_between = any(
+                        first_open < j < last_open for j in ccv_indices
+                    )
+                    if ccv_between:
+                        coordinated = True
+                        target.add(opens_before_close[0])
+                    else:
+                        nested = True
+                        target.add(opens_before_close[-1])
+            if not nested and not coordinated:
+                target.add(preferred[0])
+        else:
+            pure = [i for i, it in enumerate(tagged_list) if "M:Y_SSCCV" in str(it)]
+            target.add((pure or ssccv_indices)[0])
+
+    parts = []
+    for i, item in enumerate(tagged_list):
+        item = str(item)
+        if item.startswith("<M:Y_") and item.endswith(">"):
+            start = item.find(">") + 1
+            end = item.rfind("<")
+            surface = item[start:end] if end > start else item
+            parts.append(f"[{surface}]" if i in target else surface)
+        else:
+            parts.append(item)
+
+    text = " ".join(parts)
+    text = re.sub(r"\s+\[([,;:])", r"[\1", text)
+    text = re.sub(r"(?<!\[)\[([A-Za-z])", r" [\1", text)
+    text = re.sub(r"\[\s+", "[", text)
+    text = re.sub(r"\s+\]", "]", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    text = re.sub(
+        r"\[([,;:])\]\s+(who|which|that|whom|whose)\b",
+        r"[\1 \2]",
+        text,
+        flags=re.I,
+    )
+    return text
+
+
+def _align_span(sentence, tokenizer, model, label_list):
+    if re.search(r"\[:\]\s*$", sentence):
+        sentence = sentence + " blah blah blah."
+
+    inputs = tokenizer.encode(sentence, return_tensors="pt").to(device)
+    with torch.no_grad():
+        outputs = model(inputs)[0]
+    predictions = torch.argmax(outputs, dim=2)
+    tokens = tokenizer.convert_ids_to_tokens(inputs[0].tolist())
+    span_tagged = [
+        (tok, label_list[pred])
+        for tok, pred in zip(tokens, predictions[0].tolist())
+    ]
+    span_preds = [p for _, p in span_tagged]
+
+    sc = clean_for_spaCy(sentence) if ("[" in sentence and "]" in sentence) else sentence
+    doc = nlp(sc)
+    spacy_tokens = [t.text for t in doc]
+    spacy_pos = [t.tag_ for t in doc]
+    spacy_lemmas = [t.lemma_ for t in doc]
+
+    # Strip special tokens from BERT side for alignment
+    bert_toks = [t for t in tokens if t not in ("[CLS]", "[SEP]", "<s>", "</s>")]
+    bert_preds = [
+        p
+        for t, p in zip(tokens, span_preds)
+        if t not in ("[CLS]", "[SEP]", "<s>", "</s>")
+    ]
+
+    aligned_tokens, aligned_pos, aligned_lemmas, aligned_preds = [], [], [], []
+    if tokenizations is not None:
+        a2b, _ = tokenizations.get_alignments(spacy_tokens, bert_toks)
+        for i in range(len(spacy_tokens)):
+            if a2b[i]:
+                j = a2b[i][0]
+                aligned_tokens.append(spacy_tokens[i])
+                aligned_pos.append(spacy_pos[i])
+                aligned_lemmas.append(spacy_lemmas[i])
+                aligned_preds.append(
+                    bert_preds[j] if j < len(bert_preds) else "UNKNOWN"
+                )
+            else:
+                aligned_tokens.append(spacy_tokens[i])
+                aligned_pos.append(spacy_pos[i])
+                aligned_lemmas.append(spacy_lemmas[i])
+                aligned_preds.append("UNKNOWN")
+    else:
+        aligned_tokens, aligned_pos, aligned_lemmas = (
+            spacy_tokens,
+            spacy_pos,
+            spacy_lemmas,
+        )
+        aligned_preds = ["UNKNOWN"] * len(spacy_tokens)
+
+    return sign_cleaning(
+        aligned_tokens, aligned_pos, aligned_lemmas, aligned_preds
+    )
+
+
+def tag_CCV_span(sentence):
+    return _align_span(
+        sentence, CCVspanTaggingTokenizer, CCVspanTaggingModel, CCVspan_label_list
+    )
+
+
+def tag_SSCCV_span(sentence):
+    return _align_span(
+        sentence,
+        SSCCVspanTaggingTokenizer,
+        SSCCVspanTaggingModel,
+        SSCCVspan_label_list,
+    )
+
+
+def tag_CMV1_span(sentence):
+    return _align_span(
+        sentence,
+        CMV1spanTaggingTokenizer,
+        CMV1spanTaggingModel,
+        CMV1span_label_list,
+    )
+
+
+def tag_CMN1_span(sentence):
+    return _align_span(
+        sentence,
+        CMN1spanTaggingTokenizer,
+        CMN1spanTaggingModel,
+        CMN1span_label_list,
+    )
+
+
+def create_xml_sent(tokens, pos_tags, lemmas, predictions, sign_tag):
+    xml_sent = ET.Element("SENT")
+
+    if sign_tag == "M:Y_SSCCV":
+        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"
+        )
+        xml_sent.attrib["TYPE"] = "COMPLEX_NP"
+    elif sign_tag in ("M:Y_CCV", "M:Y_CMV1", "M:Y_CMN1"):
+        before_complex_constituent = ET.SubElement(
+            xml_sent, "BEFORE_COMPOUND_CONSTITUENT"
+        )
+        in_complex_constituent_beforesign = ET.SubElement(
+            xml_sent, "IN_COMPOUND_CONSTITUENT_BEFORESIGN"
+        )
+        in_complex_constituent = ET.SubElement(xml_sent, "IN_COMPOUND_CONSTITUENT")
+        in_complex_constituent_aftersign = ET.SubElement(
+            xml_sent, "IN_COMPOUND_CONSTITUENT_AFTERSIGN"
+        )
+        after_complex_constituent = ET.SubElement(
+            xml_sent, "AFTER_COMPOUND_CONSTITUENT"
+        )
+        xml_sent.attrib["TYPE"] = "COMPOUND"
+    else:
+        xml_sent.attrib["TYPE"] = str(predictions[0]) if predictions else "UNKNOWN"
+        print(
+            "BUILT XML SENTENCE:\n"
+            + ET.tostring(xml_sent, encoding="unicode")
+        )
+        return xml_sent
+
+    def add_w(parent, i):
+        w = ET.SubElement(parent, "W")
+        w.text = tokens[i]
+        w.attrib["POS"] = pos_tags[i]
+        w.attrib["LEMMA"] = lemmas[i]
+
+    x = 0
+    while x < len(tokens):
+        pr = str(predictions[x]) if x < len(predictions) else ""
+        if "_AFTERSIGN" in pr or "AFTERSIGN" in pr:
+            if re.match(
+                r"(and|but|or|that|what|when|where|which|while|who)$",
+                tokens[x],
+                re.I,
+            ):
+                if x > 0 and tokens[x - 1] in (",", ":", ";"):
+                    add_w(in_complex_constituent, x)
+                else:
+                    add_w(in_complex_constituent_aftersign, x)
+            else:
+                add_w(in_complex_constituent_aftersign, x)
+        elif pr.startswith("IN_") or "IN_COMPOUND" == pr or pr == "IN_COMPLEX_NP":
+            add_w(in_complex_constituent, x)
+        elif "BEFORESIGN" in pr:
+            add_w(in_complex_constituent_beforesign, x)
+        elif "BEFORE_" in pr:
+            add_w(before_complex_constituent, x)
+        elif "AFTER_" in pr:
+            add_w(after_complex_constituent, x)
+        else:
+            # default: treat as before-sign region for compounds
+            add_w(in_complex_constituent_beforesign, x)
+        x += 1
+
+    print(
+        "BUILT XML SENTENCE:\n" + ET.tostring(xml_sent, encoding="unicode")
+    )
+    return xml_sent
+
+
+def simplified_sent_xml_to_text(xml_el):
+    parts = []
+    for w in xml_el.iter("W"):
+        if w.text:
+            parts.append(w.text.strip())
+    s = " ".join(parts)
+    return clean_output(s)
+
+
+def get_COMPLEX_NP_type(xml_sent):
+    complex_NP_type = "UNKNOWN"
+    final_icca_pos_tag = first_icca_pos_tag = final_iccb_pos_tag = "UNKNOWN"
+    for el in xml_sent:
+        if el.tag == "IN_COMPLEX_CONSTITUENT_AFTERSIGN":
+            try:
+                first_icca_pos_tag = el[0].attrib["POS"]
+                final_icca_pos_tag = el[-1].attrib["POS"]
+            except Exception:
+                pass
+        elif el.tag == "IN_COMPLEX_CONSTITUENT_BEFORESIGN":
+            try:
+                final_iccb_pos_tag = el[-1].attrib["POS"]
+            except Exception:
+                pass
+    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",
+    ):
+        complex_NP_type = "VERB_OBJECT_RELATIVISED"
+    elif first_icca_pos_tag in ("VB", "VBD", "VBG", "VBN", "VBZ"):
+        complex_NP_type = "SUBJECT_RELATIVISED"
+    return complex_NP_type
+
+
+def CompoundSimplify(xml_sent):
+    try:
+
+        def get_text(elem):
+            if elem is None:
+                return ""
+            parts = []
+            for w in elem.findall("W"):
+                if w.text:
+                    t = re.sub(r"[\[\]]+", "", str(w.text).strip())
+                    if t:
+                        parts.append(t)
+            return " ".join(parts).strip()
+
+        before_elem = xml_sent.find(".//BEFORE_COMPOUND_CONSTITUENT")
+        beforesign_elem = xml_sent.find(".//IN_COMPOUND_CONSTITUENT_BEFORESIGN")
+        aftersign_elem = xml_sent.find(".//IN_COMPOUND_CONSTITUENT_AFTERSIGN")
+        after_elem = xml_sent.find(".//AFTER_COMPOUND_CONSTITUENT")
+
+        before_text = get_text(before_elem)
+        beforesign_text = get_text(beforesign_elem)
+        aftersign_text = get_text(aftersign_elem)
+        after_text = get_text(after_elem)
+
+        sent1 = " ".join(
+            x for x in (before_text, beforesign_text, after_text) if x
+        ).strip()
+        sent2 = " ".join(
+            x for x in (before_text, aftersign_text, after_text) if x
+        ).strip()
+
+        def tidy(s):
+            s = re.sub(r"\s+", " ", s).strip()
+            s = re.sub(r"\s+([.,!?;:])", r"\1", s)
+            s = re.sub(r",+\s*\.", ".", s)
+            s = re.sub(r",+\s*$", "", s)
+            if s and not s.endswith((".", "!", "?")):
+                s += "."
+            if s:
+                s = s[0].upper() + s[1:]
+            return s
+
+        sent1, sent2 = tidy(sent1), tidy(sent2)
+        result = []
+        if sent1:
+            result.append(sent1)
+        if sent2 and sent2 != sent1:
+            result.append(sent2)
+        print(f"CompoundSimplify produced {len(result)} sentences: {result}")
+        return result
+    except Exception as e:
+        print(f"CompoundSimplify error: {e}")
+        return []
+
+
+def SSCCVsimplify(xml_sent):
+    """Subject / object relative simplification (core SUBJECT_RELATIVISED path)."""
+    simplification = []
+    simp_sent1 = ET.Element("S")
+    simp_sent2 = ET.Element("S")
+
+    if xml_sent.attrib.get("TYPE") != "COMPLEX_NP":
+        return simplification
+
+    complex_NP_type = get_COMPLEX_NP_type(xml_sent)
+    print("SSCCV complex_NP_type:", complex_NP_type)
+
+    if complex_NP_type == "SUBJECT_RELATIVISED":
+        matrix_subject = None
+        predication = None
+        before_parts = []
+        after_parts = []
+
+        for xs_el in xml_sent:
+            if xs_el.tag == "IN_COMPLEX_CONSTITUENT":
+                # drop trailing punctuation inside the sign region if present
+                try:
+                    if len(xs_el) >= 2 and re.match(r"[,:;]$", xs_el[-2].text or ""):
+                        pass
+                except Exception:
+                    pass
+            elif xs_el.tag == "IN_COMPLEX_CONSTITUENT_BEFORESIGN":
+                matrix_subject = xs_el
+            elif xs_el.tag == "IN_COMPLEX_CONSTITUENT_AFTERSIGN":
+                # strip leading comma
+                kids = list(xs_el)
+                if kids and re.match(r"[,:;]$", kids[0].text or ""):
+                    xs_el.remove(kids[0])
+                predication = xs_el
+            elif xs_el.tag == "BEFORE_COMPLEX_CONSTITUENT":
+                before_parts.append(xs_el)
+            elif xs_el.tag == "AFTER_COMPLEX_CONSTITUENT":
+                after_parts.append(xs_el)
+
+        # sent1: before + subject + after  (matrix without relative body)
+        for bp in before_parts:
+            simp_sent1.append(bp)
+        if matrix_subject is not None:
+            simp_sent1.append(matrix_subject)
+        for ap in after_parts:
+            # strip leading comma on after
+            kids = list(ap)
+            if kids and re.match(r"[,:;]$", kids[0].text or ""):
+                ap.remove(kids[0])
+            simp_sent1.append(ap)
+
+        # sent2: subject + relative predication
+        if matrix_subject is not None:
+            simp_sent2.append(matrix_subject)
+        if predication is not None:
+            simp_sent2.append(predication)
+
+    elif complex_NP_type == "VERB_OBJECT_RELATIVISED":
+        # object relative: predication + subject; matrix keeps before/after
+        matrix_subject = predication = None
+        before_parts, after_parts = [], []
+        for xs_el in xml_sent:
+            if xs_el.tag == "IN_COMPLEX_CONSTITUENT_BEFORESIGN":
+                matrix_subject = xs_el
+            elif xs_el.tag == "IN_COMPLEX_CONSTITUENT_AFTERSIGN":
+                kids = list(xs_el)
+                if kids and re.match(r"[,:;]$", kids[0].text or ""):
+                    xs_el.remove(kids[0])
+                predication = xs_el
+            elif xs_el.tag == "BEFORE_COMPLEX_CONSTITUENT":
+                before_parts.append(xs_el)
+            elif xs_el.tag == "AFTER_COMPLEX_CONSTITUENT":
+                after_parts.append(xs_el)
+
+        for bp in before_parts:
+            simp_sent1.append(bp)
+        if matrix_subject is not None:
+            simp_sent1.append(matrix_subject)
+        for ap in after_parts:
+            kids = list(ap)
+            if kids and re.match(r"[,:;]$", kids[0].text or ""):
+                ap.remove(kids[0])
+            simp_sent1.append(ap)
+
+        if predication is not None:
+            simp_sent2.append(predication)
+        if matrix_subject is not None:
+            simp_sent2.append(matrix_subject)
+
+    if len(simp_sent1) > 0 and len(simp_sent2) > 0:
+        try:
+            simplification.append(simplified_sent_xml_to_text(simp_sent1))
+            simplification.append(simplified_sent_xml_to_text(simp_sent2))
+        except Exception as e:
+            print("SSCCVsimplify xml_to_text error:", e)
+
+    return simplification
+
+
+def split_into_sentences(text: str):
+    doc = nlp(text)
+    return [s.text.strip() for s in doc.sents if s.text.strip()]
+
+
+# =====================================================================
+# Main pipeline (GPU-decorated for ZeroGPU)
+# =====================================================================
+
+@spaces.GPU(duration=120)
+def process_text(input_text):
+    print("=== ITERATIVE SIMPLIFICATION (priority + clean tokens) ===")
+    try:
+        MAX_ITERS = 40
+        if not input_text or not str(input_text).strip():
+            return "No input text."
+
+        input_text = str(input_text)
+        input_text = re.sub(r"supposingthat", "supposing that", input_text)
+        input_text = re.sub(r'"', "''", input_text)
+        input_text = re.sub(r"\.\s+([a-z])", r".\n\1", input_text)
+        input_text = re.sub(r"mainly f or", "mainly for", input_text)
+        input_text = re.sub(r"sothat", "so that", input_text)
+        input_text = re.sub(r"in alabama", "in Alabama", input_text)
+        input_text = re.sub(
+            r"LEISURE DESIGN IS IMPORTANT WHY is",
+            "LEISURE DESIGN IS IMPORTANT\n\nWhy is",
+            input_text,
+        )
+        input_text = re.sub(r"WHEN", "When", input_text)
+        input_text = re.sub(r"WHAT'S", "What's", input_text)
+        input_text = re.sub(r"(\s+)an'", r"\1and", input_text)
+        input_text = re.sub(r"An'", "And", input_text)
+
+        raw_paragraphs = re.split(r"\n\s*\n", input_text)
+        output_paragraphs = []
+
+        for para in raw_paragraphs:
+            para = para.strip()
+            if not para:
+                continue
+            para = re.sub(r"\s*\n\s*", " ", para)
+
+            sents = split_into_sentences(para)
+            print(f"Paragraph → {len(sents)} sentence(s):")
+            for i, s in enumerate(sents, 1):
+                print(f"  [{i}] {s}")
+
+            para_simplified = []
+
+            for original_sent in sents:
+                working_set = deque([original_sent])
+                seen = set()
+                sentence_final = []
+                iters = 0
+
+                while working_set:
+                    current = working_set.popleft()
+                    iters += 1
+                    if iters > MAX_ITERS:
+                        print("MAX_ITERS reached; flushing rest as final")
+                        sentence_final.append(current)
+                        sentence_final.extend(working_set)
+                        break
+
+                    key = re.sub(r"\s+", " ", current.lower()).strip()
+                    if key in seen:
+                        sentence_final.append(current)
+                        continue
+                    seen.add(key)
+
+                    print(f"\n--- iter {iters} | q={len(working_set)} | {current[:80]}...")
+
+                    tagged_list = tag_all_signs_in_sent(current)
+                    tagged_str = " ".join(str(x) for x in tagged_list)
+
+                    has_ssccv = bool(
+                        re.search(r"M:Y_SSCCV|M:Y_ESCCV", tagged_str)
+                    )
+                    has_ccv = "M:Y_CCV" in tagged_str
+                    has_cmv1 = "M:Y_CMV1" in tagged_str
+                    has_cmn1 = "M:Y_CMN1" in tagged_str
+
+                    if not (has_ssccv or has_ccv or has_cmv1 or has_cmn1):
+                        sentence_final.append(current)
+                        print(f"    No target signs → final: {current}")
+                        continue
+
+                    # Priority: SSCCV > CCV > CMV1 > CMN1
+                    if has_ssccv:
+                        mode, xml_tag, span_fn, simplifier = (
+                            "ssccv",
+                            "M:Y_SSCCV",
+                            tag_SSCCV_span,
+                            SSCCVsimplify,
+                        )
+                    elif has_ccv:
+                        mode, xml_tag, span_fn, simplifier = (
+                            "ccv",
+                            "M:Y_CCV",
+                            tag_CCV_span,
+                            CompoundSimplify,
+                        )
+                    elif has_cmv1:
+                        mode, xml_tag, span_fn, simplifier = (
+                            "cmv1",
+                            "M:Y_CMV1",
+                            tag_CMV1_span,
+                            CompoundSimplify,
+                        )
+                    else:
+                        mode, xml_tag, span_fn, simplifier = (
+                            "cmn1",
+                            "M:Y_CMN1",
+                            tag_CMN1_span,
+                            CompoundSimplify,
+                        )
+
+                    bracketed_version = build_single_sign_bracketed(
+                        tagged_list, mode=mode
+                    )
+                    print(f"Processing: {current}")
+                    print(f"Bracketed version ({mode}): {bracketed_version}")
+
+                    cleaned = (
+                        clean_for_spaCy(bracketed_version)
+                        if "[" in bracketed_version
+                        else bracketed_version
+                    )
+                    tokens, pos, lemmas, preds = span_fn(cleaned)
+                    tokens, pos, lemmas, preds = drop_bracket_tokens(
+                        tokens, pos, lemmas, preds
+                    )
+                    cleaned_tokens, clean_pos, clean_lemmas, cleaned_preds = (
+                        sign_cleaning(tokens, pos, lemmas, preds)
+                    )
+                    improved_preds = improve_predicted_tag_sequence(cleaned_preds)
+                    if mode in ("ccv", "cmv1", "cmn1"):
+                        improved_preds = normalize_compound_preds(improved_preds)
+
+                    xml_sent = create_xml_sent(
+                        cleaned_tokens,
+                        clean_pos,
+                        clean_lemmas,
+                        improved_preds,
+                        xml_tag,
+                    )
+                    simps = simplifier(xml_sent)
+
+                    if not simps:
+                        print("Simplifier returned []; forcing final (no re-queue)")
+                        sentence_final.append(current)
+                        continue
+
+                    queued_any = False
+                    for s in simps:
+                        plain_s = clean_output(s)
+                        if not plain_s:
+                            continue
+                        plain_key = re.sub(r"\s+", " ", plain_s.lower())
+                        if plain_key == key:
+                            sentence_final.append(plain_s)
+                            continue
+                        if plain_key in seen:
+                            sentence_final.append(plain_s)
+                            continue
+                        working_set.append(plain_s)
+                        queued_any = True
+                        print(f"  → Queued: {plain_s}")
+
+                    if not queued_any:
+                        sentence_final.append(current)
+
+                # discourse order within this original sentence’s results
+                ordered = order_sentences_for_discourse(
+                    [clean_output(s) for s in sentence_final if clean_output(s)]
+                )
+                para_simplified.extend(ordered)
+
+            if para_simplified:
+                output_paragraphs.append(" ".join(para_simplified))
+
+        final_output = "\n\n".join(output_paragraphs)
+        print(f"\n=== FINAL OUTPUT ===\n{final_output}")
+        return final_output if final_output else "No simplification produced"
+
+    except Exception as e:
+        import traceback
+
+        print(traceback.format_exc())
+        return f"ERROR: {str(e)}"
+
+
+# =====================================================================
+# Gradio UI
+# =====================================================================
+
+custom_css = """
+.input-text textarea {
+    font-size: 16px !important;
+    color: #ff1493 !important;       /* bright pink */
+    font-weight: 500 !important;
+    line-height: 1.45 !important;
+}
+.output-text textarea {
+    font-size: 16px !important;
+    color: #00c853 !important;       /* bright green */
+    font-weight: 500 !important;
+    line-height: 1.45 !important;
+}
+.input-text label,
+.output-text label {
+    font-size: 15px !important;
+    font-weight: 600 !important;
+}
+.input-text label { color: #ff8a80 !important; }
+.output-text label { color: #69f0ae !important; }
+"""
+
+print("Creating Gradio interface...")
+
+with gr.Blocks(title="Syntactic Sentence Simplifier") as demo:
+    gr.Markdown("# Syntactic Sentence Simplifier")
+    gr.Markdown(
+        "Paste or type text below. Handles relative clauses (SSCCV) and "
+        "coordination (CCV, CMV1, CMN1) with iterative simplification."
+    )
+    input_text = gr.Textbox(
+        lines=10,
+        label="Original text",
+        placeholder="Paste your text here...",
+        elem_classes=["input-text"],
+    )
+    output_text = gr.Textbox(
+        lines=10,
+        label="Simplified text",
+        elem_classes=["output-text"],
+    )
+    btn = gr.Button("Process & Simplify", variant="primary")
+    btn.click(fn=process_text, inputs=input_text, outputs=output_text)
+
+print("Gradio interface ready. Starting web server...")
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        css=custom_css,
+    )