File size: 5,922 Bytes
06671aa
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
def _resolve_target_in_paragraph(
    para_text: str,
    target_text: str,
    before_anchor: str,
    after_anchor: str,
) -> Optional[ResolveResult]:
    para_map = _build_char_map(para_text)

    # --- Layer 1: Exact match ---
    exact_positions = _find_all(para_text, target_text)
    if len(exact_positions) == 1:
        return ResolveResult(
            target_text=target_text,
            before_anchor=before_anchor,
            after_anchor=after_anchor,
            strategy="exact",
            confidence=1.0,
            paragraph_id="",
        )
    if len(exact_positions) > 1:
        if before_anchor or after_anchor:
            for pos in exact_positions:
                if before_anchor and para_text[:pos].endswith(before_anchor):
                    return ResolveResult(
                        target_text=target_text,
                        before_anchor=before_anchor,
                        after_anchor=after_anchor,
                        strategy="exact",
                        confidence=1.0,
                        paragraph_id="",
                    )
                if after_anchor and para_text[pos + len(target_text):].startswith(after_anchor):
                    return ResolveResult(
                        target_text=target_text,
                        before_anchor=before_anchor,
                        after_anchor=after_anchor,
                        strategy="exact",
                        confidence=1.0,
                        paragraph_id="",
                    )

    # --- Layer 2: Whitespace-insensitive match ---
    norm_target = _normalize_for_match(target_text)
    if norm_target:
        norm_positions = _find_all(para_map.normalized, norm_target)

        # If no exact case match, try case-insensitive
        if not norm_positions:
            norm_lower = norm_target.lower()
            para_lower = para_map.normalized.lower()
            norm_positions_ci = _find_all(para_lower, norm_lower)
            if norm_positions_ci and len(norm_positions_ci) == 1:
                norm_positions = norm_positions_ci

        if len(norm_positions) == 1:
            ns = norm_positions[0]
            ne = ns + len(norm_target)
            orig_start, orig_end = _map_norm_range_to_orig(para_map, ns, ne)
            resolved = para_text[orig_start:orig_end]
            return ResolveResult(
                target_text=resolved,
                before_anchor="",
                after_anchor="",
                strategy="whitespace_normalized",
                confidence=0.95,
                paragraph_id="",
                was_resolved=True,
            )

        if len(norm_positions) > 1:
            # --- Layer 3: Anchor-aware normalized match ---
            norm_before = _normalize_for_match(before_anchor) if before_anchor else ""
            norm_after = _normalize_for_match(after_anchor) if after_anchor else ""

            best_idx: Optional[int] = None
            best_score = -1

            for pos in norm_positions:
                end_pos = pos + len(norm_target)
                score = 0

                if norm_before:
                    prefix = para_map.normalized[max(0, pos - len(norm_before)):pos]
                    if prefix.lower().endswith(norm_before.lower()):
                        score += 2
                    elif prefix[-len(norm_before):].lower() == norm_before[-len(prefix):].lower() if len(prefix) >= len(norm_before) else prefix.lower() == norm_before[-len(prefix):].lower():
                        score += 1

                if norm_after:
                    suffix_start = end_pos
                    suffix = para_map.normalized[suffix_start:suffix_start + len(norm_after)]
                    if suffix.lower().startswith(norm_after.lower()):
                        score += 2
                    elif suffix[:len(norm_after)].lower() == norm_after[:len(suffix)].lower() if len(suffix) >= len(norm_after) else suffix.lower() == norm_after[:len(suffix)].lower():
                        score += 1

                if score > best_score:
                    best_score = score
                    best_idx = pos

            if best_idx is not None and best_score > 0:
                ns = best_idx
                ne = ns + len(norm_target)
                orig_start, orig_end = _map_norm_range_to_orig(para_map, ns, ne)
                resolved = para_text[orig_start:orig_end]
                return ResolveResult(
                    target_text=resolved,
                    before_anchor="",
                    after_anchor="",
                    strategy="anchor_normalized",
                    confidence=0.8 if best_score >= 3 else 0.65,
                    paragraph_id="",
                    was_resolved=True,
                )

    # --- Layer 4: Sentence-level fallback ---
    sentences = _sentence_tokenize(para_text)
    target_bigrams = _char_bigrams(target_text)
    if target_bigrams and sentences:
        scored: list[tuple[float, int, int]] = []
        for s_start, s_end in sentences:
            sent = para_text[s_start:s_end]
            sent_bigrams = _char_bigrams(sent)
            score = _bigram_containment(target_bigrams, sent_bigrams)
            scored.append((score, s_start, s_end))
        scored.sort(key=lambda x: x[0], reverse=True)
        if scored:
            best = scored[0]
            runner_up = scored[1][0] if len(scored) > 1 else 0.0
            if best[0] >= 0.70 and best[0] - runner_up > 0.10:
                resolved = para_text[best[1]:best[2]]
                return ResolveResult(
                    target_text=resolved,
                    before_anchor="",
                    after_anchor="",
                    strategy="sentence_fallback",
                    confidence=round(best[0], 2),
                    paragraph_id="",
                    was_resolved=True,
                )

    return None