v4.2: Update app.py

app.py

@@ -1,6 +1,15 @@
 """
-ClauseGuard — World's Best Legal Contract Analysis Tool (v4.1)
+ClauseGuard — World's Best Legal Contract Analysis Tool (v4.2)
 ═══════════════════════════════════════════════════════════════
+Fixes in v4.2:
+  • FIX: NLI now uses CrossEncoder.predict() — contradictions actually work
+  • FIX: BoundedCache uses threading.RLock — no more race conditions
+  • FIX: Pre-compiled ALL regex patterns at module level (perf)
+  • FIX: Added missing regex labels to RISK_MAP/DESC_MAP
+  • FIX: Extension risk formula matches backend
+  • FIX: Extension API_BASE URL corrected
+  • FIX: API CORS localhost requires explicit opt-in
+
 Fixes in v4.1:
   • FIX: Bounded LRU caches (chunk_cache, prediction_cache) — no more memory leaks
   • FIX: NLI input format — pass (text_a, text_b) tuple, not [SEP]-concatenated string
@@ -44,6 +53,7 @@ import io
 import uuid
 import tempfile
 import hashlib
+import threading
 from collections import defaultdict, OrderedDict
 from datetime import datetime
 from functools import lru_cache
@@ -80,6 +90,14 @@ try:
 except Exception:
     pass
 
+# ── CrossEncoder for NLI (soft-fail) ──────────────────────────────────
+_HAS_CROSS_ENCODER = False
+try:
+    from sentence_transformers import CrossEncoder as _CrossEncoder
+    _HAS_CROSS_ENCODER = True
+except ImportError:
+    pass
+
 # ── Import submodules ───────────────────────────────────────────────
 from compare import compare_contracts, render_comparison_html
 from obligations import extract_obligations, render_obligations_html
@@ -142,7 +160,12 @@ _UNFAIR_LABELS = [
     "Jurisdiction", "Arbitration"
 ]
 
-_ALL_LABELS = CUAD_LABELS + _UNFAIR_LABELS
+# FIX v4.2: Include regex-only labels that aren't in CUAD or Unfair lists
+_EXTRA_REGEX_LABELS = [
+    "Indemnification", "Confidentiality", "Force Majeure", "Penalties"
+]
+
+_ALL_LABELS = CUAD_LABELS + _UNFAIR_LABELS + _EXTRA_REGEX_LABELS
 
 RISK_MAP = {
     # Critical
@@ -198,6 +221,11 @@ RISK_MAP = {
     "Other": "LOW",
     "ROFR/ROFO/ROFN": "LOW",
     "Contract by using": "LOW",
+    # FIX v4.2: Added regex-only labels that were missing from RISK_MAP
+    "Indemnification": "HIGH",
+    "Confidentiality": "MEDIUM",
+    "Force Majeure": "LOW",
+    "Penalties": "HIGH",
 }
 
 DESC_MAP = {label: label.replace("_", " ") for label in _ALL_LABELS}
@@ -238,6 +266,11 @@ DESC_MAP.update({
     "Irrevocable or Perpetual License": "License that cannot be revoked or lasts indefinitely.",
     "Unlimited/All-You-Can-Eat License": "License with no usage limits.",
     "Notice Period to Terminate Renewal": "Required notice period before automatic renewal.",
+    # FIX v4.2: Added descriptions for regex-only labels
+    "Indemnification": "Obligation to compensate the other party for losses or damages.",
+    "Confidentiality": "Restrictions on sharing proprietary or sensitive information.",
+    "Force Majeure": "Excuses performance due to extraordinary events beyond control.",
+    "Penalties": "Financial penalties for breach or late performance.",
 })
 
 RISK_WEIGHTS = {"CRITICAL": 40, "HIGH": 20, "MEDIUM": 10, "LOW": 3}
@@ -267,31 +300,39 @@ for _i in range(41):
 # ═══════════════════════════════════════════════════════════════════════
 
 class BoundedCache:
-    """Thread-safe bounded LRU cache using OrderedDict."""
+    """Thread-safe bounded LRU cache using OrderedDict + RLock.
+    FIX v4.2: Added threading.RLock to prevent race conditions under
+    Gradio's concurrent request handling. OrderedDict compound operations
+    (contains + setitem + move_to_end + popitem) are NOT atomic even with GIL."""
     def __init__(self, maxsize=1000):
         self._cache = OrderedDict()
         self._maxsize = maxsize
+        self._lock = threading.RLock()
 
     def get(self, key, default=None):
-        if key in self._cache:
-            self._cache.move_to_end(key)
-            return self._cache[key]
-        return default
+        with self._lock:
+            if key in self._cache:
+                self._cache.move_to_end(key)
+                return self._cache[key]
+            return default
 
     def put(self, key, value):
-        if key in self._cache:
-            self._cache.move_to_end(key)
-            self._cache[key] = value
-        else:
-            if len(self._cache) >= self._maxsize:
-                self._cache.popitem(last=False)
-            self._cache[key] = value
+        with self._lock:
+            if key in self._cache:
+                self._cache.move_to_end(key)
+                self._cache[key] = value
+            else:
+                if len(self._cache) >= self._maxsize:
+                    self._cache.popitem(last=False)
+                self._cache[key] = value
 
     def __contains__(self, key):
-        return key in self._cache
+        with self._lock:
+            return key in self._cache
 
     def __len__(self):
-        return len(self._cache)
+        with self._lock:
+            return len(self._cache)
 
 
 # ═══════════════════════════════════════════════════════════════════════
@@ -301,7 +342,7 @@ class BoundedCache:
 cuad_tokenizer = None
 cuad_model = None
 ner_pipeline = None
-nli_pipeline = None
+nli_model = None  # FIX v4.2: CrossEncoder instead of pipeline
 _model_status = {"cuad": "not_loaded", "ner": "not_loaded", "nli": "not_loaded"}
 
 def _load_cuad_model():
@@ -349,20 +390,16 @@ def _load_ner_model():
         _model_status["ner"] = f"failed: {e}"
 
 def _load_nli_model():
-    global nli_pipeline, _model_status, _HAS_NLI_MODEL
-    if not _HAS_TORCH:
-        _model_status["nli"] = "unavailable"
+    global nli_model, _model_status, _HAS_NLI_MODEL
+    if not _HAS_CROSS_ENCODER:
+        _model_status["nli"] = "unavailable (sentence-transformers not installed)"
         return
     try:
-        print("[ClauseGuard] Loading NLI model: cross-encoder/nli-deberta-v3-base")
-        nli_pipeline = pipeline(
-            "text-classification",
-            model="cross-encoder/nli-deberta-v3-base",
-            device=-1,
-        )
+        print("[ClauseGuard] Loading NLI model: cross-encoder/nli-deberta-v3-base (CrossEncoder)")
+        nli_model = _CrossEncoder("cross-encoder/nli-deberta-v3-base")
         _HAS_NLI_MODEL = True
         _model_status["nli"] = "loaded"
-        print("[ClauseGuard] NLI model loaded successfully")
+        print("[ClauseGuard] NLI CrossEncoder loaded successfully")
     except Exception as e:
         print(f"[ClauseGuard] NLI model load failed (using heuristic fallback): {e}")
         _model_status["nli"] = f"failed: {e}"
@@ -430,6 +467,18 @@ def parse_document(file_path):
 
 _chunk_cache = BoundedCache(maxsize=500)
 
+# FIX v4.2: Pre-compile section pattern at module level (was recompiling per call)
+_SECTION_PATTERN = re.compile(
+    r'(?:^|\n\n)'
+    r'(?='
+    r'\d+(?:\.\d+)*[.)]\s'   # 1. 2. 3.1. 3.1)
+    r'|[A-Z]{2,}[A-Z\s]*\n'  # ALL CAPS HEADERS
+    r'|\([a-z]\)\s'           # (a) (b) (c)
+    r'|(?:Section|Article|Clause)\s+\d+'  # Section 1, Article 2
+    r')',
+    re.MULTILINE
+)
+
 def split_clauses(text):
     """Deterministic, structure-aware clause splitting.
     Same input ALWAYS produces same output. Normalized text is hashed
@@ -443,18 +492,7 @@ def split_clauses(text):
     text = re.sub(r'\n{3,}', '\n\n', text.strip())
 
     # First try to detect numbered sections (1., 2., 3.1, (a), etc.)
-    section_pattern = re.compile(
-        r'(?:^|\n\n)'
-        r'(?='
-        r'\d+(?:\.\d+)*[.)]\s'   # 1. 2. 3.1. 3.1)
-        r'|[A-Z]{2,}[A-Z\s]*\n'  # ALL CAPS HEADERS
-        r'|\([a-z]\)\s'           # (a) (b) (c)
-        r'|(?:Section|Article|Clause)\s+\d+'  # Section 1, Article 2
-        r')',
-        re.MULTILINE
-    )
-
-    positions = [m.start() for m in section_pattern.finditer(text)]
+    positions = [m.start() for m in _SECTION_PATTERN.finditer(text)]
 
     if len(positions) >= 3:
         clauses = []
@@ -688,14 +726,19 @@ _REGEX_PATTERNS = {
     "Price Restriction": [r"price.*(?:restriction|limitation|ceiling|cap|floor)", r"(?:shall|may).*not.*(?:increase|raise|exceed).*price"],
 }
 
+# FIX v4.2: Pre-compile regex patterns at module level (was recompiling per call)
+_REGEX_PATTERNS_COMPILED = {}
+for _label, _pats in _REGEX_PATTERNS.items():
+    _REGEX_PATTERNS_COMPILED[_label] = [re.compile(p, re.IGNORECASE) for p in _pats]
+
 def _classify_regex(text):
     """Regex fallback — returns pattern match, NOT fake confidence."""
     text_lower = text.lower()
     results = []
     seen = set()
-    for label, patterns in _REGEX_PATTERNS.items():
+    for label, patterns in _REGEX_PATTERNS_COMPILED.items():
         for pat in patterns:
-            if re.search(pat, text_lower):
+            if pat.search(text_lower):
                 if label not in seen:
                     risk = RISK_MAP.get(label, "MEDIUM")
                     results.append({
@@ -816,29 +859,21 @@ def _extract_entities_regex(text):
 # ═══════════════════════════════════════════════════════════════════════
 
 def _run_nli(text_a, text_b):
-    """Run NLI pipeline with correct input format for cross-encoder.
-    FIX v4.1: cross-encoder expects {'text': a, 'text_pair': b} or a dict,
-    but the HF pipeline for text-classification with cross-encoder accepts
-    a dict input: {"text": text_a, "text_pair": text_b}.
-    The simplest correct way is to pass them as a list of dicts."""
+    """Run NLI using CrossEncoder with correct input format.
+    FIX v4.2: Use sentence_transformers.CrossEncoder.predict() which accepts
+    a list of (text_a, text_b) tuples. Returns scores for [contradiction, entailment, neutral].
+    The old code used pipeline("text-classification") with dict input, which was broken."""
     try:
-        # The cross-encoder/nli-deberta-v3-base pipeline expects two texts.
-        # Passing as a dict with text and text_pair is the correct format.
-        result = nli_pipeline(
-            {"text": text_a[:256], "text_pair": text_b[:256]},
-            truncation=True,
-        )
-        return result
-    except Exception:
-        # Some pipeline versions accept positional (text, text_pair) as tuple
-        try:
-            return nli_pipeline(
-                text_a[:256],
-                text_pair=text_b[:256],
-                truncation=True,
-            )
-        except Exception:
-            return None
+        # CrossEncoder.predict returns numpy array of shape (n_pairs, 3)
+        # Columns: [contradiction, entailment, neutral]
+        scores = nli_model.predict([(text_a[:256], text_b[:256])])
+        label_mapping = ["contradiction", "entailment", "neutral"]
+        top_idx = int(scores[0].argmax())
+        top_score = float(scores[0][top_idx])
+        return [{"label": label_mapping[top_idx], "score": top_score}]
+    except Exception as e:
+        print(f"[ClauseGuard] NLI inference error: {e}")
+        return None
 
 
 def detect_contradictions(clause_results, raw_text=""):
@@ -857,7 +892,7 @@ def detect_contradictions(clause_results, raw_text=""):
         clause_texts_by_label[cr["label"]].append(cr.get("text", ""))
 
     # ── 1. Semantic NLI (if model available) ──
-    if _HAS_NLI_MODEL and nli_pipeline is not None:
+    if _HAS_NLI_MODEL and nli_model is not None:
         conflict_pairs = [
             ("Uncapped Liability", "Cap on Liability",
              "Liability cannot be both uncapped and capped simultaneously."),