| |
| """Run Span-01 on one public Perch benchmark and score the saved predictions. |
| |
| Requires RESPAN_API_KEY for new calls. The key is only read from the process |
| environment; it is never saved in predictions or reports. This script uses the |
| same method/context layout and behavior definitions as the recorded run. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import math |
| import os |
| from pathlib import Path |
| import sys |
| import time |
| from urllib.error import HTTPError, URLError |
| from urllib.request import Request, urlopen |
|
|
| import benchmark as core |
|
|
|
|
| API = 'https://api.respan.ai/api/v1/scores' |
| LINT_URL = 'https://huggingface.co/datasets/perchscan/perch-lint-bench-public/resolve/main/benchmark.jsonl' |
| MODEL = 'span-01-pro' |
| REVISION = 'span-01-pro (API revision not published)' |
| PROTOCOL = 'respan-span01-pro-perch-pack-v1' |
|
|
|
|
| def load_data(domain: str, path: Path | None): |
| if domain != 'lint': |
| return core.load_pairs(domain, path) |
| raw = path.read_bytes() if path else urlopen(LINT_URL, timeout=120).read() |
| pairs = [json.loads(line) for line in raw.splitlines() if line] |
| if not pairs or len({pair['pair_id'] for pair in pairs}) != len(pairs): |
| raise ValueError('Empty or duplicate lint pairs') |
| return pairs, hashlib.sha256(raw).hexdigest() |
|
|
|
|
| def questions_for(pack: dict, domain: str, language: str) -> list[dict]: |
| return core.detection_questions(core.scan_questions(pack, domain, language), domain) |
|
|
|
|
| def issue_definition(q: dict) -> str: |
| criteria = q['question']['criteria'] |
| issue_on = q['issue'].get('on', True) |
| present = ' '.join(criteria['true' if issue_on else 'false'].split()) |
| absent = ' '.join(criteria['false' if issue_on else 'true'].split()) |
| if issue_on: |
| question = ' '.join(q['question']['instructions'].split()) |
| return (f'The target method has this issue: {question} ' |
| f'Present when: {present} Absent when: {absent}') |
| return (f'The target method violates its stated behavior. ' |
| f'Present when: {present} Absent when: {absent}') |
|
|
|
|
| def method_parts(pair: dict, side: dict) -> tuple[str, str]: |
| state = side['state'] |
| method = state.get('method') or {} |
| language = pair.get('language') or 'unknown' |
| context = [f'LANGUAGE: {language}'] |
| for name, title in (('imports', 'IMPORTS'), ('module_scope', 'MODULE SCOPE'), |
| ('call_graph', 'CALL GRAPH EDGES'), ('called_by', 'CALLERS'), |
| ('calls', 'CALLEES')): |
| value = state.get(name) |
| if not value: |
| continue |
| if isinstance(value, list): |
| rendered = '\n'.join( |
| item if isinstance(item, str) else |
| f"{item.get('name', '')} ({item.get('path', '')})\n{item.get('source', '')}" |
| for item in value) |
| else: |
| rendered = str(value) |
| context.append(f'{title}:\n{rendered}') |
| target = (f"PATH: {method.get('path') or side.get('path') or ''}\n" |
| f"METHOD: {method.get('name') or side.get('method_name') or ''}\n" |
| f"{method.get('source') or side.get('source') or ''}") |
| return '\n\n'.join(context), target |
|
|
|
|
| def behaviors_for(pair: dict, domain: str, pack: dict): |
| if domain == 'lint': |
| ensure = ' '.join(pair['rule']['ensure'].split()) |
| return [{'id': 'rule_satisfied', |
| 'definition': 'The target method satisfies this requirement: ' + ensure}], [] |
| questions = questions_for(pack, domain, pair['language']) |
| if not questions: |
| raise ValueError(f'No questions for {domain}:{pair["language"]}') |
| return [{'id': q['name'], 'definition': issue_definition(q)} for q in questions], questions |
|
|
|
|
| def call_api(pair: dict, role: str, behaviors: list[dict], key: str): |
| context, target = method_parts(pair, pair[role]) |
| payload = {'model': MODEL, |
| 'span': {'input': [{'role': 'user', 'content': context}], |
| 'output': {'role': 'assistant', 'content': target}}, |
| 'behaviors': behaviors} |
| raw = json.dumps(payload, ensure_ascii=False).encode() |
| for attempt in range(9): |
| request = Request(API, data=raw, method='POST', |
| headers={'Authorization': f'Bearer {key}', |
| 'Content-Type': 'application/json'}) |
| try: |
| with urlopen(request, timeout=120) as response: |
| result = json.load(response) |
| break |
| except HTTPError as exc: |
| if exc.code not in (429, 500, 502, 503, 504) or attempt == 8: |
| raise RuntimeError(f'Span-01 HTTP {exc.code} for {pair["pair_id"]}:{role}') from None |
| try: |
| seconds = float(json.loads(exc.read()).get('retry_after', 0)) |
| except (ValueError, TypeError, AttributeError): |
| seconds = 0 |
| time.sleep(max(seconds, min(60, 2 ** attempt))) |
| except URLError: |
| if attempt == 8: |
| raise RuntimeError(f'Span-01 network failure for {pair["pair_id"]}:{role}') from None |
| time.sleep(min(60, 2 ** attempt)) |
| if result.get('model') != MODEL: |
| raise ValueError(f'Unexpected model: {result.get("model")}') |
| by_id = {item['id']: item for item in result['results']} |
| if by_id.keys() != {b['id'] for b in behaviors}: |
| raise ValueError('Missing or duplicate behavior result') |
| for item in by_id.values(): |
| values = [item[k] for k in ('p_present', 'p_absent', 'p_not_observable')] |
| if not all(isinstance(p, (float, int)) and math.isfinite(p) and 0 <= p <= 1 |
| for p in values) or abs(sum(values) - 1) > .01: |
| raise ValueError('Invalid behavior probabilities') |
| return by_id, result.get('usage') or {} |
|
|
|
|
| def predicted_row(pair: dict, role: str, domain: str, pack: dict, key: str): |
| behaviors, questions = behaviors_for(pair, domain, pack) |
| answers, usage = call_api(pair, role, behaviors, key) |
| if domain == 'lint': |
| scores = {'rule_violation': answers['rule_satisfied']['p_absent']} |
| unknown = {'rule_violation': answers['rule_satisfied']['p_not_observable']} |
| alert = scores['rule_violation'] > .7 |
| else: |
| scores = {name: item['p_present'] for name, item in answers.items()} |
| unknown = {name: item['p_not_observable'] for name, item in answers.items()} |
| alert = any(scores[q['name']] > max(.5, (q.get('min') or 0) / 100) |
| for q in questions) |
| return {'domain': domain, 'pair_id': pair['pair_id'], 'role': role, |
| 'score': max(scores.values()), 'question_scores': scores, |
| 'not_observable': unknown, 'alert': alert, 'usage': usage, |
| 'model_revision': REVISION, 'protocol_id': PROTOCOL, |
| 'pack_sha256': pack['pack_sha256'] if domain != 'lint' else None} |
|
|
|
|
| def score_report(pairs: list[dict], predictions: dict, domain: str, pack: dict, digest: str): |
| if domain != 'lint': |
| report = core.report(pairs, predictions, domain, digest, REVISION, |
| pack['protocol_id'], .5, pack) |
| report['protocol_id'] = PROTOCOL |
| else: |
| items = [] |
| for pair in pairs: |
| for role in ('before', 'after'): |
| row = predictions[pair['pair_id'], role] |
| label = pair[role]['labels'][pair['domain']] |
| items.append((label, row['score'], row['score'] > .7)) |
| tp = sum(y and a for y, _, a in items) |
| fp = sum(not y and a for y, _, a in items) |
| fn = sum(y and not a for y, _, a in items) |
| tn = sum(not y and not a for y, _, a in items) |
| eligible = correct = ties = 0 |
| for pair in pairs: |
| if pair['before']['labels'][pair['domain']] and not pair['after']['labels'][pair['domain']]: |
| eligible += 1 |
| a = predictions[pair['pair_id'], 'before']['score'] |
| b = predictions[pair['pair_id'], 'after']['score'] |
| correct += a > b |
| ties += a == b |
| precision = tp / (tp + fp) if tp + fp else 0.0 |
| recall = tp / (tp + fn) if tp + fn else 0.0 |
| report = {'domain': 'lint', 'model_revision': REVISION, 'protocol_id': PROTOCOL, |
| 'threshold': .7, 'alert_rule': 'rule violation score > 0.7', |
| 'benchmark_sha256': digest, 'benchmark_pairs': len(pairs), |
| 'benchmark_methods': len(items), |
| 'average_precision': core.average_precision([(y, s) for y, s, _ in items]), |
| 'precision': precision, 'recall': recall, |
| 'f1': 2 * tp / (2 * tp + fp + fn) if 2 * tp + fp + fn else 0.0, |
| 'confusion': {'tp': tp, 'fp': fp, 'tn': tn, 'fn': fn}, |
| 'vulnerable_or_buggy_before_above_fixed_after': |
| {'correct': correct, 'ties': ties, 'eligible': eligible}} |
| tokens = sum((row.get('usage') or {}).get('input_tokens', 0) for row in predictions.values()) |
| report['input_tokens'] = tokens |
| report['inference_cost_usd'] = tokens * .02 / 1_000_000 |
| report['methods_max_not_observable_over_50pct'] = sum( |
| max(row['not_observable'].values()) > .5 for row in predictions.values()) |
| return report |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--domain', choices=('bug', 'security', 'lint'), required=True) |
| parser.add_argument('--dataset', type=Path, help='Local benchmark.jsonl; defaults to public HF pairs') |
| parser.add_argument('--question-pack', type=Path, default=Path(__file__).with_name('question-pack.json')) |
| parser.add_argument('--predictions', type=Path, required=True) |
| parser.add_argument('--report', type=Path, required=True) |
| parser.add_argument('--limit', type=int, default=0, help='New method sides to score this run; 0 means all') |
| parser.add_argument('--score-saved', action='store_true', help='Only score complete saved predictions') |
| args = parser.parse_args() |
| if args.limit < 0: |
| parser.error('--limit must be nonnegative') |
| pack = core.load_pack(args.question_pack) |
| pairs, digest = load_data(args.domain, args.dataset) |
| expected = {(pair['pair_id'], role) for pair in pairs for role in ('before', 'after')} |
| predictions = {} |
| if args.predictions.exists(): |
| for line in args.predictions.read_text().splitlines(): |
| if not line: |
| continue |
| row = json.loads(line) |
| identity = row['pair_id'], row['role'] |
| if (identity not in expected or identity in predictions or row['domain'] != args.domain |
| or row.get('protocol_id') != PROTOCOL): |
| raise ValueError(f'Unknown, duplicate, or wrong-protocol prediction: {identity}') |
| predictions[identity] = row |
| pending = [(pair, role) for pair in pairs for role in ('before', 'after') |
| if (pair['pair_id'], role) not in predictions] |
| if args.score_saved and pending: |
| raise ValueError(f'Incomplete: {len(pending)} method sides missing') |
| if args.limit: |
| pending = pending[:args.limit] |
| if pending: |
| key = os.getenv('RESPAN_API_KEY') |
| if not key: |
| raise RuntimeError('Set RESPAN_API_KEY to run Span-01') |
| args.predictions.parent.mkdir(parents=True, exist_ok=True) |
| with args.predictions.open('a') as output: |
| for index, (pair, role) in enumerate(pending, 1): |
| row = predicted_row(pair, role, args.domain, pack, key) |
| predictions[pair['pair_id'], role] = row |
| output.write(json.dumps(row, sort_keys=True) + '\n') |
| output.flush() |
| if index % 100 == 0 or index == len(pending): |
| print(f'Scored {len(predictions)}/{len(expected)} method sides', file=sys.stderr) |
| if predictions.keys() != expected: |
| print(f'Incomplete: {len(predictions)}/{len(expected)}; rerun to resume', file=sys.stderr) |
| return |
| result = score_report(pairs, predictions, args.domain, pack, digest) |
| args.report.parent.mkdir(parents=True, exist_ok=True) |
| args.report.write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') |
| print(json.dumps(result, sort_keys=True)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
