Update app.py

app.py

@@ -357,6 +357,11 @@ required_sign_tags = [
 # Helper functions (refactored from notebook)
 ###############################################################################
 
+###############################################################################
+def is_cognitive_communicative_vp(preds):
+    return any("COGNITIVE_COMMUNICATIVE_VP" in str(p) for p in (preds or []))
+###############################################################################
+
 ###############################################################################
 # Third-person (and similar) pronouns that usually need an antecedent.
 # Omit I/you/me — deictic, not anaphoric in the same way.
@@ -794,8 +799,8 @@ def highlight_tokens_html(tokens, labels):
 ###############################################################################
 def highlight_sentence_if_ssccv(sentence):
     """
-    SignTagger -> bracket leftmost SSCCV sign -> SSCCVspanTagger
-    -> HTML with cognitive/communicative VP spans coloured.
+    SignTagger -> bracket one SSCCV sign -> SSCCVspanTagger
+    -> HTML with cognitive/communicative VP underlined.
     """
     sentence = (sentence or "").strip()
     if not sentence:
@@ -806,9 +811,10 @@ def highlight_sentence_if_ssccv(sentence):
         return html.escape(sentence)
 
     bracketed = build_single_sign_bracketed(tagged_list, mode="ssccv")
-    tokens, pos, lemmas, preds = tag_SSCCV_span(bracketed)
+    if not bracketed:
+        return html.escape(sentence)
 
-    # Predictions are already spaCy-aligned by tag_SSCCV_span
+    tokens, pos, lemmas, preds = tag_SSCCV_span(bracketed)
     return highlight_tokens_html(tokens, preds)
 ###############################################################################
 
@@ -1883,6 +1889,9 @@ def fix_subject_verb_agreement(sent: str) -> str:
     if not sent or not sent.strip():
         return sent
 
+    if re.search(r"\bdo(?:es|ing)?\s+so\b", sentence, flags=re.I):
+        return sentence
+    
     sent = sent.strip()
     doc = nlp(sent)
     if not doc:
@@ -2393,21 +2402,26 @@ def drop_bracket_tokens(tokens, pos, lemmas, preds):
 ###############################################################################
 
 ###############################################################################
-def build_single_sign_bracketed(tagged_list, mode="ccv"):
+def build_single_sign_bracketed(tagged_list, mode="ccv", skip_indices=None):
     """
     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 = "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
+
+    skip_indices: token offsets already tried and rejected
+                  (e.g. SSCCV signs whose span is a cognitive/communicative VP).
+    Returns None if nothing remains to bracket for this mode.
     """
 
+    skip_indices = set(skip_indices or [])
+
     def surface_of(item):
         if item.startswith("<M:Y_") and ">" in item:
             start = item.find(">") + 1
@@ -2425,6 +2439,8 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
     ssmn_indices = []
 
     for i, item in enumerate(tagged_list):
+        if i in skip_indices:
+            continue
         s = str(item)
         if "<M:Y_CCV>" in s or "M:Y_CCV" in s:
             ccv_indices.append(i)
@@ -2442,7 +2458,7 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
                 ssccv_indices.append(i)
         if "M:Y_SSMN" in s:
             ssmn_indices.append(i)
-                
+
     target = set()
 
     if mode == "ccv" and ccv_indices:
@@ -2458,8 +2474,8 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
         target.add(cln_indices[-1])
 
     elif mode == "ssmn" and ssmn_indices:
-        target.add(ssmn_indices[0])  # leftmost appositive boundary
-        
+        target.add(ssmn_indices[0])
+
     elif mode == "ssccv" and ssccv_indices:
         relative_pronouns = {"who", "which", "whom", "whose"}
         preferred = []
@@ -2467,12 +2483,10 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
         for i in ssccv_indices:
             surface = surface_of(tagged_list[i]).strip().lower()
 
-            # Direct relative pronoun as the tagged sign
             if surface in relative_pronouns:
                 preferred.append(i)
                 continue
 
-            # Punctuation that introduces a relative (e.g. "," before "who")
             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":
@@ -2490,25 +2504,30 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
                 if len(opens_before_close) >= 2:
                     first_open = opens_before_close[0]
                     last_open = opens_before_close[-1]
-                    # CCV between relative openers → coordinated relatives, not nesting
                     ccv_between = any(
                         first_open < j < last_open for j in ccv_indices
                     )
                     if ccv_between:
                         coordinated = True
-                        target.add(opens_before_close[0])  # leftmost / whole relative
+                        target.add(opens_before_close[0])
                     else:
                         nested = True
-                        target.add(opens_before_close[-1])  # innermost
+                        target.add(opens_before_close[-1])
 
             if not nested and not coordinated:
-                target.add(preferred[0])  # single relative or siblings
+                target.add(preferred[0])
         else:
             pure_ssccv = [
-                i for i, item in enumerate(tagged_list)
-                if "M:Y_SSCCV" in str(item)
+                i
+                for i, item in enumerate(tagged_list)
+                if i not in skip_indices and "M:Y_SSCCV" in str(item)
             ]
-            target.add((pure_ssccv or ssccv_indices)[0])
+            pool = pure_ssccv or ssccv_indices
+            if pool:
+                target.add(pool[0])
+
+    if not target:
+        return None
 
     parts = []
     for i, item in enumerate(tagged_list):
@@ -2525,14 +2544,12 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
 
     text = " ".join(parts)
 
-    # spacing
     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()
 
-    # merge [, who] / [, which] style
     text = re.sub(
         r"\[([,;:])\]\s+(who|which|that|whom|whose)\b",
         r"[\1 \2]",
@@ -2541,7 +2558,6 @@ def build_single_sign_bracketed(tagged_list, mode="ccv"):
     )
 
     return text
-
 ###############################################################################
 
 ###############################################################################
@@ -2581,11 +2597,9 @@ def process_text(input_text):
             para = re.sub(r"\s+", " ", para).strip()
 
             sents = split_into_sentences(para)
-
             if not sents:
-                # continue
-                return "No input text.", "No input text."
-            
+                continue
+
             print(f"Paragraph → {len(sents)} sentence(s):")
             for i, s in enumerate(sents, 1):
                 print(f"  [{i}] {s}")
@@ -2606,7 +2620,7 @@ def process_text(input_text):
                             f"ABORT: exceeded {MAX_ITERS} iterations; "
                             f"draining {len(working_set)} item(s) to final"
                         )
-                        while working_set: 
+                        while working_set:
                             sentence_final.append(
                                 clean_output(working_set.popleft())
                             )
@@ -2655,53 +2669,104 @@ def process_text(input_text):
                         "<M:Y_CLN>" in t or "M:Y_CLN" in t for t in tagged_list
                     )
 
+                    skipped_ssccv = set()
+                    mode = xml_tag = None
+                    simplifier = span_fn = None
+                    bracketed_version = None
+
+                    # SSCCV first, but skip cognitive/communicative VPs
                     if has_ssccv:
-                        mode = "ssccv"
-                        xml_tag = "M:Y_SSCCV"
-                        simplifier = SSCCVsimplify
-                        span_fn = tag_SSCCV_span
-                    elif has_ssmn:
+                        while True:
+                            bracketed_version = build_single_sign_bracketed(
+                                tagged_list,
+                                mode="ssccv",
+                                skip_indices=skipped_ssccv,
+                            )
+                            if not bracketed_version:
+                                break
+
+                            print(f"\nProcessing: {current}")
+                            print(
+                                f"Bracketed version (ssccv): {bracketed_version}"
+                            )
+
+                            cleaned = clean_for_spaCy(bracketed_version)
+                            tokens, pos, lemmas, preds = tag_SSCCV_span(cleaned)
+                            tokens, pos, lemmas, preds = drop_bracket_tokens(
+                                tokens, pos, lemmas, preds
+                            )
+
+                            if is_cognitive_communicative_vp(preds):
+                                ssccv_idxs = [
+                                    i
+                                    for i, t in enumerate(tagged_list)
+                                    if "M:Y_SSCCV" in str(t)
+                                    or "M:Y_ESCCV" in str(t)
+                                ]
+                                remaining = [
+                                    i
+                                    for i in ssccv_idxs
+                                    if i not in skipped_ssccv
+                                ]
+                                if remaining:
+                                    skipped_ssccv.add(remaining[0])
+                                print(
+                                    "  Skip SSCCV "
+                                    "(cognitive/communicative VP)"
+                                )
+                                continue
+
+                            mode = "ssccv"
+                            xml_tag = "M:Y_SSCCV"
+                            simplifier = SSCCVsimplify
+                            span_fn = tag_SSCCV_span
+                            break
+
+                    if mode is None and has_ssmn:
                         mode = "ssmn"
                         xml_tag = "M:Y_SSMN"
                         simplifier = SSMNsimplify
                         span_fn = tag_SSMN_span
-                    elif has_ccv:
+                    elif mode is None and has_ccv:
                         mode = "ccv"
                         xml_tag = "M:Y_CCV"
                         simplifier = CompoundSimplify
                         span_fn = tag_CCV_span
-                    elif has_cmv1:
+                    elif mode is None and has_cmv1:
                         mode = "cmv1"
                         xml_tag = "M:Y_CMV1"
                         simplifier = CompoundSimplify
                         span_fn = tag_CMV1_span
-                    elif has_cmn1:
+                    elif mode is None and has_cmn1:
                         mode = "cmn1"
                         xml_tag = "M:Y_CMN1"
                         simplifier = CompoundSimplify
                         span_fn = tag_CMN1_span
-                    elif has_cln:
+                    elif mode is None and has_cln:
                         mode = "cln"
                         xml_tag = "M:Y_CLN"
                         simplifier = CompoundSimplify
                         span_fn = tag_CLN_span
-                    else:
+                    elif mode is None:
                         sentence_final.append(current)
                         continue
 
-                    bracketed_version = build_single_sign_bracketed(
-                        tagged_list, mode=mode
-                    )
-
-                    print(f"\nProcessing: {current}")
-                    print(f"Bracketed version ({mode}): {bracketed_version}")
-
-                    cleaned = clean_for_spaCy(bracketed_version)
-                    tokens, pos, lemmas, preds = span_fn(cleaned)
-
-                    tokens, pos, lemmas, preds = drop_bracket_tokens(
-                        tokens, pos, lemmas, preds
-                    )
+                    if mode != "ssccv":
+                        bracketed_version = build_single_sign_bracketed(
+                            tagged_list, mode=mode
+                        )
+                        if not bracketed_version:
+                            sentence_final.append(current)
+                            continue
+                        print(f"\nProcessing: {current}")
+                        print(
+                            f"Bracketed version ({mode}): {bracketed_version}"
+                        )
+                        cleaned = clean_for_spaCy(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)
@@ -2721,7 +2786,6 @@ def process_text(input_text):
                     if simps:
                         simps = [fix_subject_verb_agreement(s) for s in simps]
 
-                    # Residual comma → same conjunction (CCV / CMV1 / CMN1 / CLN only)
                     if (
                         simps
                         and simplifier is CompoundSimplify
@@ -2741,10 +2805,8 @@ 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":
                         simps = [fix_subject_verb_agreement(s) for s in simps]
-                    
 
                     if not simps:
                         print(
@@ -2793,13 +2855,17 @@ def process_text(input_text):
 
         final_output = "\n\n".join(output_paragraphs)
         print(f"\n=== FINAL OUTPUT ===\n{final_output}")
-        highlighted = highlight_final_output(final_output)
-        return highlighted
+        return highlight_final_output(final_output)
 
     except Exception as e:
         import traceback
+
         print(traceback.format_exc())
-        return f'<div class="simp-out">{html.escape("ERROR: " + str(e))}</div>'
+        return (
+            f'<div class="simp-out">'
+            f"{html.escape('ERROR: ' + str(e))}"
+            f"</div>"
+        )
         
 ###########################################################################