fix(qa): SonarCloud cleanup

- whitelist_vulture: bare names -> _ = expr (fixes 16 S905 BUG false-positives)
- contextbench_diffctx: drop unused 'ok' params from breakdown helpers
- common.py run_parallel: extract _run_pool/_run_serial/_collect_result (S3776 17->under 15)
- forensic_contextbench evaluate_one: extract header/dump helpers (S3776 19->under 15)
- graph.py: use np.divide(out=) instead of /= so SonarCloud sees mutation

Author: nikolay-e

benchmarks/common.py

@@ -298,29 +298,35 @@ def worker_dir(base: Path) -> Path:
     return d
 
 
-def run_parallel(worker_fn, run_args: list, workers: int, collect: str = "append") -> list:
+def _collect_result(results: list, r, collect: str) -> None:
+    if collect == "extend":
+        results.extend(r)
+    elif r:
+        results.append(r)
+
+
+def _run_serial(worker_fn, run_args: list, collect: str) -> list:
     results: list = []
-    if workers > 1:
-        from concurrent.futures import ProcessPoolExecutor, as_completed
-
-        with ProcessPoolExecutor(max_workers=workers, initializer=_init_worker) as pool:
-            futures = {pool.submit(worker_fn, a): a[0] for a in run_args}
-            for future in as_completed(futures):
-                try:
-                    r = future.result()
-                except Exception as e:
-                    idx = futures[future]
-                    print(f"  WORKER CRASH [{idx}]: {type(e).__name__}: {e}", flush=True)
-                    continue
-                if collect == "extend":
-                    results.extend(r)
-                elif r:
-                    results.append(r)
-    else:
-        for a in run_args:
-            r = worker_fn(a)
-            if collect == "extend":
-                results.extend(r)
-            elif r:
-                results.append(r)
+    for a in run_args:
+        _collect_result(results, worker_fn(a), collect)
     return results
+
+
+def _run_pool(worker_fn, run_args: list, workers: int, collect: str) -> list:
+    from concurrent.futures import ProcessPoolExecutor, as_completed
+
+    results: list = []
+    with ProcessPoolExecutor(max_workers=workers, initializer=_init_worker) as pool:
+        futures = {pool.submit(worker_fn, a): a[0] for a in run_args}
+        for future in as_completed(futures):
+            try:
+                _collect_result(results, future.result(), collect)
+            except Exception as e:
+                print(f"  WORKER CRASH [{futures[future]}]: {type(e).__name__}: {e}", flush=True)
+    return results
+
+
+def run_parallel(worker_fn, run_args: list, workers: int, collect: str = "append") -> list:
+    if workers > 1:
+        return _run_pool(worker_fn, run_args, workers, collect)
+    return _run_serial(worker_fn, run_args, collect)

benchmarks/contextbench_diffctx.py

@@ -338,7 +338,7 @@ def evaluate_instance(
     return result
 
 
-def _print_per_language_breakdown(ok: list[dict], by_lang: dict) -> None:
+def _print_per_language_breakdown(by_lang: dict) -> None:
     if len(by_lang) <= 1:
         return
     print("\nPer-language breakdown:")
@@ -350,7 +350,7 @@ def _print_per_language_breakdown(ok: list[dict], by_lang: dict) -> None:
         print(f"  {lang:12s} (n={len(lr):3d}): file_recall={avg_fr:.3f}  nontrivial={avg_ntr:.3f}  line_recall={avg_lr:.3f}")
 
 
-def _print_per_repo_breakdown(ok: list[dict], by_repo: dict) -> None:
+def _print_per_repo_breakdown(by_repo: dict) -> None:
     if len(by_repo) <= 1:
         return
     print("\nPer-repo breakdown:")
@@ -405,12 +405,12 @@ def aggregate(results: list[dict]) -> None:
     by_lang: dict[str, list[dict]] = defaultdict(list)
     for r in ok:
         by_lang[r["language"]].append(r)
-    _print_per_language_breakdown(ok, by_lang)
+    _print_per_language_breakdown(by_lang)
 
     by_repo: dict[str, list[dict]] = defaultdict(list)
     for r in ok:
         by_repo[r["repo"]].append(r)
-    _print_per_repo_breakdown(ok, by_repo)
+    _print_per_repo_breakdown(by_repo)
 
     zero_frag = sum(1 for r in ok if r["fragments"] == 0)
     zero_line = sum(1 for r in ok if r["line_recall"] < 1e-9 and r["fragments"] > 0)

benchmarks/forensic_contextbench.py

@@ -235,82 +235,79 @@ def _classify_nontrivial_stages(
     return stage_per_file
 
 
-def evaluate_one(inst: dict, budget: int) -> dict:
-    iid = inst["instance_id"]
+def _print_instance_header(
+    inst: dict, gold_blocks: list, gold_set: set, p_set: set, added: set, deleted: set, modified: set, nontrivial: set
+) -> None:
     print("\n" + "=" * 78)
-    print(f"INSTANCE: {iid}")
+    print(f"INSTANCE: {inst['instance_id']}")
     print(f"Repo: {inst['repo']}  Lang: {inst['language']}")
     print(f"Base: {inst['base_commit'][:12]}")
-
-    gold_blocks = json.loads(inst["gold_context"]) if isinstance(inst["gold_context"], str) else inst["gold_context"]
-    for g in gold_blocks:
-        g["file"] = normalize_gold_path(g["file"])
-    gold_set = {g["file"] for g in gold_blocks}
-    added, deleted, modified = patch_files_detailed(inst["patch"])
-    p_set = added | deleted | modified
-    nontrivial = gold_set - p_set
-
     print(f"\n[GOLD]      {len(gold_set):3d} files, {len(gold_blocks):3d} blocks")
     for f in sorted(gold_set)[:8]:
         marker = " (in patch)" if f in p_set else " (NONTRIVIAL)"
         print(f"  {f}{marker}")
     if len(gold_set) > 8:
         print(f"  ... and {len(gold_set) - 8} more")
-
     print(f"\n[PATCH]     {len(p_set):3d} files (added={len(added)}, deleted={len(deleted)}, modified={len(modified)})")
     if deleted:
         print(f"  DELETED FILES: {sorted(deleted)}")
-
     print(f"\n[NONTRIVIAL GOLD] {len(nontrivial):3d} files")
 
-    repo_dir = ensure_repo(inst["repo_url"], inst["repo"], inst["base_commit"], REPOS_DIR)
-    if not repo_dir:
-        return {"id": iid, "status": "clone_fail"}
-
-    if not apply_as_commit(repo_dir, inst["patch"]):
-        run_cmd(["git", "-C", str(repo_dir), "checkout", "--force", inst["base_commit"]], check=False)
-        return {"id": iid, "status": "apply_fail"}
 
-    t0 = time.time()
-    output, err = run_diffctx(repo_dir, budget)
-    elapsed = time.time() - t0
-
-    if not output:
-        run_cmd(["git", "-C", str(repo_dir), "reset", "--hard", "HEAD~1"], check=False)
-        print(f"  DIFFCTX FAIL: {err}")
-        return {"id": iid, "status": "diffctx_fail"}
-
-    selected = {f["path"] for f in output["fragments"]}
+def _print_pipeline_dump(
+    output: dict, elapsed: float, p_set: set, deleted: set, repo_dir: Path, nontrivial: set, gold_set: set, selected: set
+) -> tuple[set, set, set]:
     print(f"\n[DIFFCTX]   {len(selected):3d} files, {output['fragment_count']:3d} fragments, {elapsed:.1f}s")
-
     _print_patch_coverage(p_set, selected, deleted, repo_dir)
-
-    nontrivial_hits = nontrivial & selected
-    nontrivial_missed = nontrivial - selected
     universe = read_dump_set("universe.txt")
     fragmented = read_dump_set("fragmented.txt")
     sel_dump = read_dump_set("selected.txt")
     candidates_info = (DUMP_DIR / "candidates.txt").read_text().strip() if (DUMP_DIR / "candidates.txt").exists() else ""
-
     print(f"\n[PIPELINE STAGES]\n  {candidates_info}")
     print(f"  universe: {len(universe)}  fragmented: {len(fragmented)}  selected: {len(sel_dump)}")
-
-    _print_nontrivial_report(nontrivial, nontrivial_hits, nontrivial_missed, fragmented, universe, sel_dump)
-
+    nontrivial_hits = nontrivial & selected
+    _print_nontrivial_report(nontrivial, nontrivial_hits, nontrivial - selected, fragmented, universe, sel_dump)
     extra = selected - gold_set
     if extra:
         print(f"\n[DIFFCTX EXTRA]  {len(extra)} files not in gold")
         for f in sorted(extra)[:5]:
             print(f"    {f} ({'patch' if f in p_set else 'discovered'})")
+    return universe, fragmented, sel_dump
 
-    run_cmd(["git", "-C", str(repo_dir), "reset", "--hard", "HEAD~1"], check=False)
 
-    file_recall = len(gold_set & selected) / len(gold_set)
-    nt_recall = len(nontrivial_hits) / len(nontrivial) if nontrivial else 0.0
-    patch_coverage = len(p_set & selected) / len(p_set) if p_set else 0.0
+def evaluate_one(inst: dict, budget: int) -> dict:
+    iid = inst["instance_id"]
+    gold_blocks = json.loads(inst["gold_context"]) if isinstance(inst["gold_context"], str) else inst["gold_context"]
+    for g in gold_blocks:
+        g["file"] = normalize_gold_path(g["file"])
+    gold_set = {g["file"] for g in gold_blocks}
+    added, deleted, modified = patch_files_detailed(inst["patch"])
+    p_set = added | deleted | modified
+    nontrivial = gold_set - p_set
+    _print_instance_header(inst, gold_blocks, gold_set, p_set, added, deleted, modified, nontrivial)
 
-    stage_per_file = _classify_nontrivial_stages(nontrivial, selected, sel_dump, fragmented, universe)
+    repo_dir = ensure_repo(inst["repo_url"], inst["repo"], inst["base_commit"], REPOS_DIR)
+    if not repo_dir:
+        return {"id": iid, "status": "clone_fail"}
+    if not apply_as_commit(repo_dir, inst["patch"]):
+        run_cmd(["git", "-C", str(repo_dir), "checkout", "--force", inst["base_commit"]], check=False)
+        return {"id": iid, "status": "apply_fail"}
+
+    t0 = time.time()
+    output, err = run_diffctx(repo_dir, budget)
+    elapsed = time.time() - t0
+    if not output:
+        run_cmd(["git", "-C", str(repo_dir), "reset", "--hard", "HEAD~1"], check=False)
+        print(f"  DIFFCTX FAIL: {err}")
+        return {"id": iid, "status": "diffctx_fail"}
+
+    selected = {f["path"] for f in output["fragments"]}
+    universe, fragmented, sel_dump = _print_pipeline_dump(
+        output, elapsed, p_set, deleted, repo_dir, nontrivial, gold_set, selected
+    )
+    run_cmd(["git", "-C", str(repo_dir), "reset", "--hard", "HEAD~1"], check=False)
 
+    nontrivial_hits = nontrivial & selected
     return {
         "id": iid,
         "status": "ok",
@@ -319,10 +316,10 @@ def evaluate_one(inst: dict, budget: int) -> dict:
         "n_patch": len(p_set),
         "n_nontrivial": len(nontrivial),
         "n_deleted_in_patch": len(deleted),
-        "patch_coverage": round(patch_coverage, 3),
-        "file_recall": round(file_recall, 3),
-        "nt_recall": round(nt_recall, 3),
-        "stage_per_file": stage_per_file,
+        "patch_coverage": round(len(p_set & selected) / len(p_set) if p_set else 0.0, 3),
+        "file_recall": round(len(gold_set & selected) / len(gold_set), 3),
+        "nt_recall": round(len(nontrivial_hits) / len(nontrivial) if nontrivial else 0.0, 3),
+        "stage_per_file": _classify_nontrivial_stages(nontrivial, selected, sel_dump, fragmented, universe),
     }
 
 

src/treemapper/diffctx/graph.py

@@ -283,7 +283,8 @@ def _suppress_semantic_hubs(
         sem_file_deg[si] = len(files)
     src_sem_deg = sem_file_deg[src_idx]
     sem_hub_mask = is_semantic & (src_sem_deg >= _HUB_OUT_DEGREE_THRESHOLD)
-    weights /= np.where(sem_hub_mask, np.sqrt(src_sem_deg.astype(np.float64)), 1.0)
+    divisor = np.where(sem_hub_mask, np.sqrt(src_sem_deg.astype(np.float64)), 1.0)
+    np.divide(weights, divisor, out=weights)
 
 
 def _apply_hub_suppression(

whitelist_vulture.py

@@ -7,34 +7,34 @@
 from treemapper.diffctx.tokenizer import detect_profile, is_nlp_available
 from treemapper.mcp.server import get_diff_context, get_file_context, get_tree_map, run_server
 
-clipboard_available
-detect_profile
-is_nlp_available
-Graph.add_node
-Graph.to_csr
-Graph.ego_graph
-QuotientNode.fragment_count
+_ = clipboard_available
+_ = detect_profile
+_ = is_nlp_available
+_ = Graph.add_node
+_ = Graph.to_csr
+_ = Graph.ego_graph
+_ = QuotientNode.fragment_count
 _ = ProjectGraph.edges_of_type
 _ = ProjectGraph.subgraph
-get_diff_context
-get_tree_map
-get_file_context
-run_server
-DiffContextTimeoutError
-git.is_git_repo
-git.get_diff_text
-git.parse_diff
-git.split_diff_range
-git.get_commit_message
-universe._expand_universe_by_rare_identifiers
-universe._resolve_changed_files
-universe._discover_untracked_files
-universe._synthetic_hunks
-universe._enrich_concepts
-types.DiffHunk.core_selection_range
-types.extract_identifier_list
-file_importance.compute_file_importance
-fragmentation._create_whole_file_fragment
-graph_analytics.blast_radius
-CSRGraph.out_weight_sum
-CSRGraph.idx_to_node
+_ = get_diff_context
+_ = get_tree_map
+_ = get_file_context
+_ = run_server
+_ = DiffContextTimeoutError
+_ = git.is_git_repo
+_ = git.get_diff_text
+_ = git.parse_diff
+_ = git.split_diff_range
+_ = git.get_commit_message
+_ = universe._expand_universe_by_rare_identifiers
+_ = universe._resolve_changed_files
+_ = universe._discover_untracked_files
+_ = universe._synthetic_hunks
+_ = universe._enrich_concepts
+_ = types.DiffHunk.core_selection_range
+_ = types.extract_identifier_list
+_ = file_importance.compute_file_importance
+_ = fragmentation._create_whole_file_fragment
+_ = graph_analytics.blast_radius
+_ = CSRGraph.out_weight_sum
+_ = CSRGraph.idx_to_node