""" Deterministic Span Compiler & Slice-Cut Verifier. Single-label non-autoregressive speech disfluency excision. No target strings, no generative repairs — pure substring-to-offset compilation, orphan comma absorption, and 100% roundtrip reconstruction assertions. """ import re from typing import List, Optional, Tuple from schema import DatasetExample, RawCandidate, Span def clean_punctuation_whitespace(text: str) -> str: """ Deterministic post-excision cleanup matching Vox's Tier 1 itn.rs runtime: - Collapses duplicate spaces - Collapses spaces before punctuation: "word , next" -> "word, next" - Collapses multiple commas: "word, , next" -> "word, next" - Collapses comma followed by terminal punctuation: ",." -> "." - Trims leading/trailing whitespace """ text = re.sub(r"[ \t]+", " ", text) text = re.sub(r"\s+([,.\?!।;:])", r"\1", text) text = re.sub(r",\s*,+", ",", text) text = re.sub(r",\s*([.\?!।])", r"\1", text) return text.strip() def compile_candidate_to_example( candidate: RawCandidate, example_id: str ) -> Tuple[Optional[DatasetExample], Optional[str]]: """ Deterministically computes character spans from disfluent substrings and verifies 100% roundtrip reconstruction against clean_text via slice cuts. """ raw = candidate.raw_text clean = candidate.clean_text.strip() category = "CLEAN" if (not candidate.disfluent_spans and raw.strip() == clean) else "DISFLUENCY" # Boundary Gate: closed terminal sentences only (. ? ! ।). if not raw.strip() or raw.strip()[-1] not in ".?!।": return None, f"Boundary Gate: raw_text must end with closed terminal (.?!।), got '{raw[-20:]}'" if not clean or clean[-1] not in ".?!।": return None, f"Boundary Gate: clean_text must end with closed terminal (.?!।), got '{clean[-20:]}'" # Case 1: CLEAN negative control if category == "CLEAN": if candidate.disfluent_spans: return None, "CLEAN category cannot contain disfluent spans" if raw.strip() != clean: return None, f"CLEAN raw_text must equal clean_text (got raw='{raw}', clean='{clean}')" return DatasetExample( id=example_id, category="CLEAN", raw_text=raw, clean_text=clean, spans=[] ), None # Case 2: Speech Disfluency excision if not candidate.disfluent_spans: return None, "DISFLUENCY category must contain at least one disfluent span" computed_spans: List[Span] = [] search_cursor = 0 for span_str in candidate.disfluent_spans: target_str = span_str if not target_str or not target_str.strip(): return None, "Empty disfluent span string: must name a non-empty verbatim substring" start_idx = raw.find(target_str, search_cursor) if start_idx == -1: start_idx = raw.find(target_str) if start_idx == -1: return None, f"Disfluent span '{target_str}' not found in raw_text" end_idx = start_idx + len(target_str) orig_start, orig_end = start_idx, end_idx # Orphan Comma Absorption: absorb surrounding hesitation punctuation leading_text = raw[:start_idx] leading_stripped = leading_text.rstrip(" ") if leading_stripped.endswith(","): comma_pos = len(leading_stripped) - 1 start_idx = comma_pos target_str = raw[start_idx:end_idx] trailing_text = raw[end_idx:] trailing_stripped = trailing_text.lstrip(" ") if trailing_stripped.startswith(","): comma_offset = len(trailing_text) - len(trailing_stripped) + 1 end_idx += comma_offset target_str = raw[start_idx:end_idx] computed_spans.append( Span( label="speech disfluency", span=(start_idx, end_idx), text=target_str, confidence=1.0 ) ) search_cursor = end_idx # Orphan Comma Fallback: if absorbing commas breaks roundtrip, retry bare span if (orig_start, orig_end) != (start_idx, end_idx): bare_span = Span(label="speech disfluency", span=(orig_start, orig_end), text=raw[orig_start:orig_end], confidence=1.0) rest = [s for s in computed_spans if s.span[0] >= computed_spans[-1].span[1]] ok, _ = verify_roundtrip(raw, computed_spans[:-1] + [bare_span] + rest, clean) if ok: computed_spans[-1] = bare_span search_cursor = orig_end # Sort spans by start offset computed_spans.sort(key=lambda s: s.span[0]) # Check for overlapping spans for i in range(len(computed_spans) - 1): if computed_spans[i].span[1] > computed_spans[i + 1].span[0]: return None, f"Overlapping spans detected: {computed_spans[i]} and {computed_spans[i+1]}" # Verify 100% Roundtrip Reconstruction via slice cut is_valid, reconstructed = verify_roundtrip(raw, computed_spans, clean) if not is_valid: return None, f"Roundtrip assertion failed: reconstructed '{reconstructed}' != clean '{clean}'" return DatasetExample( id=example_id, category="DISFLUENCY", raw_text=raw, clean_text=clean, spans=computed_spans ), None def verify_roundtrip(raw_text: str, spans: List[Span], expected_clean: str) -> Tuple[bool, str]: """ Executes deterministic slice cuts on raw_text, collapses whitespace/commas, and checks exact equality with expected_clean. """ result_chars = [] last_idx = 0 for span in sorted(spans, key=lambda s: s.span[0]): start, end = span.span prefix = raw_text[last_idx:start] result_chars.append(prefix) # Disfluency excision: if excision causes two adjacent word characters to collide, insert single space full_so_far = "".join(result_chars).rstrip() remaining_suffix = raw_text[end:].lstrip() if full_so_far and remaining_suffix: if full_so_far[-1].isalnum() and remaining_suffix[0].isalnum(): result_chars.append(" ") last_idx = end result_chars.append(raw_text[last_idx:]) raw_reconstructed = "".join(result_chars) reconstructed = clean_punctuation_whitespace(raw_reconstructed) expected_clean_norm = clean_punctuation_whitespace(expected_clean) # Post-excision sentence capitalization parity (matches Vox Tier 1 itn.rs normalizer): if reconstructed and expected_clean_norm and expected_clean_norm[0].isupper(): reconstructed = reconstructed[0].upper() + reconstructed[1:] return (reconstructed == expected_clean_norm), reconstructed