Uploading dataset files from the local data folder.

googleadkcyber_no_venv.tar.gz.gpg

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fcd0e3c4d6c7997f5bdb47714101ad5b36c8b0132b7d4b7b85547b0b09e755e9
+size 215455381

merge_span.py

@@ -0,0 +1,308 @@
+"""
+Span merger: given a list of valid line numbers and a list of possible spans,
+produce a list of output spans that accounts for every line number.
+
+Assignment rules
+----------------
+Each line number is assigned to the span(s) closest to it:
+
+  distance(line l, span [a, b]) = max(0, a − l, l − b)
+                                = 0     if the line is inside the span,
+                                  a − l if the line is left  of the span,
+                                  l − b if the line is right of the span.
+
+A line is assigned to *every* span that achieves the minimum distance.
+When a line is equidistant between two adjacent spans both spans claim it
+at assignment time.
+
+Tie-breaking at span boundaries
+-------------------------------
+For a given span's intermediate output [start, end]:
+  • start (1st element) – when multiple assigned lines are tied as closest
+    to the span's nominal left boundary, the *smallest* is chosen (biased left).
+  • end   (2nd element) – when multiple assigned lines are tied as closest
+    to the span's nominal right boundary, the *largest* is chosen (biased right).
+
+Because the intermediate boundaries are simply min / max of the assigned
+lines these tie-breaking rules are satisfied automatically.
+
+Output normalization
+--------------------
+The returned spans are normalized after assignment:
+
+  • If two consecutive outputs touch at exactly one duplicated boundary
+    point, the earlier span is shrunk so the final output stays disjoint.
+  • If candidate spans overlap enough to create a genuine overlap in the
+    output, those overlapping outputs are merged.
+
+Special cases
+-------------
+• Empty line list  → empty output.
+• No possible spans → all lines emitted as one ``missing`` span.
+• Spans with no lines assigned to them are omitted from the output.
+"""
+
+from __future__ import annotations
+
+from typing import TypedDict
+
+
+class SpanResult(TypedDict):
+    start: int
+    end: int
+    missing: bool
+
+
+def _distance_to_span(line: int, start: int, end: int) -> int:
+    return max(0, start - line, line - end)
+
+
+def _normalize_spans(possible_spans: list[list[int]]) -> list[tuple[int, int]]:
+    normalized: list[tuple[int, int]] = []
+
+    for idx, span in enumerate(possible_spans):
+        if len(span) != 2:
+            raise ValueError(f"span at index {idx} must contain exactly two integers")
+
+        start, end = span
+        if not isinstance(start, int) or not isinstance(end, int):
+            raise TypeError(f"span at index {idx} must contain integers")
+        if start > end:
+            raise ValueError(
+                f"span at index {idx} has start > end: [{start}, {end}]"
+            )
+
+        normalized.append((start, end))
+
+    return sorted(normalized, key=lambda span: (span[0], span[1]))
+
+
+def merge_spans(
+    line_numbers: list[int],
+    possible_spans: list[list[int]],
+) -> list[SpanResult]:
+    """
+    Parameters
+    ----------
+    line_numbers:
+        Unsorted / duplicate-containing list of valid line numbers.
+    possible_spans:
+        List of [start, end] inclusive span boundaries.
+
+    Returns
+    -------
+    List of dicts ``{'start': int, 'end': int, 'missing': bool}``,
+    ordered by start position.
+
+    Each line is assigned to the span(s) with the smallest
+    ``max(0, a − l, l − b)`` distance. Lines equidistant between two
+    adjacent spans are claimed by *both* at assignment time. The final
+    returned spans are normalized so the output does not contain a
+    duplicated boundary point, and any genuine overlap caused by
+    overlapping candidate spans is merged.
+
+    The output start / end of each span is the min / max of its assigned
+    lines, which automatically implements the tie-breaking rule:
+    start biased toward smaller values, end toward larger values.
+
+    Raises
+    ------
+    ValueError
+        If any span does not contain exactly two integers or if ``start > end``.
+    TypeError
+        If any span boundary is not an integer.
+    """
+    sorted_lines = sorted(set(line_numbers))
+    spans = _normalize_spans(possible_spans)
+
+    if not sorted_lines:
+        return []
+
+    if not spans:
+        return [{"start": sorted_lines[0], "end": sorted_lines[-1], "missing": True}]
+
+    assignments: list[list[int]] = [[] for _ in spans]
+
+    for line in sorted_lines:
+        min_dist = min(_distance_to_span(line, start, end) for start, end in spans)
+        for idx, (start, end) in enumerate(spans):
+            if _distance_to_span(line, start, end) == min_dist:
+                assignments[idx].append(line)
+
+    output: list[SpanResult] = []
+    out_assignments: list[list[int]] = []
+    for assigned in assignments:
+        if assigned:
+            output.append({"start": assigned[0], "end": assigned[-1], "missing": False})
+            out_assignments.append(assigned)
+
+    i = 0
+    while i < len(output) - 1:
+        if output[i]["end"] == output[i + 1]["start"]:
+            overlap = output[i]["end"]
+            smaller = [line for line in out_assignments[i] if line < overlap]
+            if smaller:
+                output[i]["end"] = smaller[-1]
+                i += 1
+            else:
+                output.pop(i)
+                out_assignments.pop(i)
+        else:
+            i += 1
+
+    i = 0
+    while i < len(output) - 1:
+        if output[i]["end"] >= output[i + 1]["start"]:
+            output[i] = {
+                "start": output[i]["start"],
+                "end": max(output[i]["end"], output[i + 1]["end"]),
+                "missing": output[i]["missing"] or output[i + 1]["missing"],
+            }
+            output.pop(i + 1)
+        else:
+            i += 1
+
+    return output
+
+
+# --------------------------------------------------------------------------- #
+# Formatting helper                                                             #
+# --------------------------------------------------------------------------- #
+
+def format_spans(spans: list[SpanResult]) -> str:
+    parts = []
+    for s in spans:
+        tag = f"[{s['start']},{s['end']}]"
+        parts.append(tag)
+    return "[" + ", ".join(parts) + "]"
+
+
+# --------------------------------------------------------------------------- #
+# Smoke-tests                                                                  #
+# --------------------------------------------------------------------------- #
+
+if __name__ == "__main__":
+    cases = [
+        # ── Original examples ──────────────────────────────────────────── #
+        {
+            "label": "Example 1 – pre-line absorbed into nearest span; empty span dropped",
+            "lines": [1, 3, 5, 6, 7, 8, 9, 10, 12, 15],
+            "spans": [[2, 5], [6, 15], [16, 20]],
+            "expected": "[[1,5], [6,15]]",
+        },
+        {
+            "label": "Example 2 – line 5 equidistant → prev span end shrunk from 5→3",
+            "lines": [1, 3, 5, 6, 7, 8, 9, 10, 12, 18],
+            "spans": [[2, 4], [6, 14], [16, 20]],
+            "expected": "[[1,3], [5,12], [18,18]]",
+        },
+        # ── Edge cases ─────────────────────────────────────────────────── #
+        {
+            "label": "EC-01  empty line list → empty output",
+            "lines": [],
+            "spans": [[1, 5], [6, 10]],
+            "expected": "[]",
+        },
+        {
+            "label": "EC-02  no spans → all lines become missing groups",
+            # Bug: the old else-branch would double-emit everything.
+            "lines": [2, 3, 7, 8],
+            "spans": [],
+            "expected": "[[2,8]]",
+        },
+        {
+            "label": "EC-03  all lines left of only span → absorbed as nearest",
+            "lines": [1, 2, 3],
+            "spans": [[10, 20]],
+            "expected": "[[1,3]]",
+        },
+        {
+            "label": "EC-04  all lines right of only span → absorbed as nearest",
+            "lines": [15, 16, 20],
+            "spans": [[1, 10]],
+            "expected": "[[15,20]]",
+        },
+        {
+            "label": "EC-05  adjacent spans → each line goes to the span it is inside",
+            "lines": [1, 3, 5, 8],
+            "spans": [[1, 4], [5, 10]],
+            "expected": "[[1,3], [5,8]]",
+        },
+        {
+            "label": "EC-06  duplicate line numbers → deduplicated before processing",
+            "lines": [3, 3, 5, 5, 7],
+            "spans": [[1, 10]],
+            "expected": "[[3,7]]",
+        },
+        {
+            "label": "EC-07  line 7 equidistant → prev span end shrunk from 7→3",
+            "lines": [3, 7, 11],
+            "spans": [[1, 5], [9, 15]],
+            "expected": "[[3,3], [7,11]]",
+        },
+        {
+            "label": "EC-08  empty gap → each line assigned to the span it is inside, no overlap",
+            "lines": [2, 4, 8, 12],
+            "spans": [[1, 5], [7, 15]],
+            "expected": "[[2,4], [8,12]]",
+        },
+        {
+            "label": "EC-09  single line, span wider than needed → clipped at line",
+            "lines": [5],
+            "spans": [[3, 7]],
+            "expected": "[[5,5]]",
+        },
+        {
+            "label": "EC-10  line 6 equidistant → prev span end shrunk from 6→2",
+            "lines": [2, 6, 7, 11, 15],
+            "spans": [[1, 4], [8, 12], [14, 20]],
+            "expected": "[[2,2], [6,11], [15,15]]",
+        },
+        {
+            "label": "EC-11  single span → all lines (pre and inside) absorbed as nearest",
+            "lines": [1, 2, 5, 6, 15],
+            "spans": [[10, 20]],
+            "expected": "[[1,15]]",
+        },
+        {
+            "label": "EC-12  first span gets no lines; subsequent spans absorb orphans",
+            "lines": [3, 8],
+            "spans": [[1, 2], [5, 7], [10, 15]],
+            "expected": "[[3,3], [8,8]]",
+        },
+        {
+            "label": "EC-13  line 10 equidistant → prev span end shrunk from 10→5",
+            "lines": [1, 5, 10, 15, 20],
+            "spans": [[3, 8], [12, 18]],
+            "expected": "[[1,5], [10,20]]",
+        },
+        {
+            "label": "EC-14  overlap where prev span has no smaller line → prev span dropped",
+            # line 7 equidistant between [1,5] and [9,15]: both claim it.
+            # span 0 assigned=[7] only; no line < 7 exists → span 0 is dropped.
+            "lines": [7, 11],
+            "spans": [[1, 5], [9, 15]],
+            "expected": "[[7,11]]",
+        },
+        {
+            "label": "EC-15  overlapping possible spans → genuine overlap merged in pass 2",
+            # spans [1,8] and [3,10] overlap; lines 4 and 6 are inside both →
+            # both spans claim 4 and 6, so output before pass 2 = [[2,6],[4,9]].
+            # pass 1 sees 6 != 4 (strict >), skips; pass 2 merges → [[2,9]].
+            "lines": [2, 4, 6, 9],
+            "spans": [[1, 8], [3, 10]],
+            "expected": "[[2,9]]",
+        },
+    ]
+
+    for case in cases:
+        result = merge_spans(case["lines"], case["spans"])
+        formatted = format_spans(result)
+        status = "✓" if formatted == case["expected"] else "✗"
+        print(f"{status} {case['label']}")
+        print(f"    lines:    {case['lines']}")
+        print(f"    spans:    {case['spans']}")
+        print(f"    output:   {formatted}")
+        print(f"    expected: {case['expected']}")
+        print()
+