Blame for span01.py

#!/usr/bin/env python3
"""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()