"""Durable teacher/proposal/review rounds with source-only access checks."""
from __future__ import annotations

import argparse
from dataclasses import asdict, replace
import hashlib
import json
from pathlib import Path
import random

import numpy as np
from scipy.optimize import linear_sum_assignment
import torch

from .workflow import Box, Provenance, annotation_digest, is_resolved, load_jsonl, merge_proposals, save_jsonl
from pallet.audit_proposals import iou_xywh
from pallet.data.protocol import file_digest, load_protocol, write_json
from pallet.data.loader import NormalizationStats, apply_normalization, load_frame
from pallet.devices import resolve_device
from pallet.experiments.dataset import SampleMeta, letterbox_float
from pallet.experiments.evaluate import predict_boxes
from pallet.export import load_detector_checkpoint
from pallet.matrix import _is_completed


def _audit_changed(before, after, *, minimum_iou=.85):
    if before.status != after.status:
        return True
    for left, right in ((before.boxes, after.boxes),
                        (before.ignore_regions, after.ignore_regions)):
        if len(left) != len(right):
            return True
        if not left:
            continue
        scores = np.array([[iou_xywh((a.x, a.y, a.width, a.height),
                                     (b.x, b.y, b.width, b.height))
                            for b in right] for a in left])
        benefit = (scores >= minimum_iou).astype(float) + (
            scores * (scores >= minimum_iou) / (min(scores.shape) + 1))
        matched_left, matched_right = linear_sum_assignment(-benefit)
        if np.any(scores[matched_left, matched_right] < minimum_iou):
            return True
    return False


def _validate_labels(records, annotations, assignments):
    for row in records:
        frame = annotations.frames.get(row.frame_id)
        if frame is not None and (frame.group_id != row.group_id
                or frame.split != assignments.get(row.group_id)
                or frame.source_anchor_hash != row.source_sha256):
            raise ValueError(f'annotation differs from frozen split/group/anchor: {row.frame_id}')


def _teacher_access(records, assignments, run, audit_groups, target_domain):
    audit = set(audit_groups)
    target = {row.group_id for row in records if row.domain == target_domain}
    if not audit or any(assignments.get(group) != 'train' for group in audit) or audit & target:
        raise ValueError('audit groups must be frozen source-training groups')
    if 'train_groups' not in run or 'val_groups' not in run:
        raise ValueError('teacher must declare training and validation access')
    accessed = set().union(*(set(run.get(key, ())) for key in (
        'train_groups', 'val_groups', 'normalization_groups', 'tuning_groups', 'accessed_groups')))
    if accessed & (audit | target):
        raise ValueError('teacher training/validation access includes audit or target groups')
    if any(assignments.get(group) != 'train' for group in run['train_groups']):
        raise ValueError('teacher training groups differ from frozen source training')
    if any(assignments.get(group) != 'val' for group in run['val_groups']):
        raise ValueError('teacher validation groups differ from frozen source validation')
    return accessed


def _state_digest(state):
    return hashlib.sha256(json.dumps({k: v for k, v in state.items()
        if k != 'state_sha256'}, sort_keys=True, separators=(',', ':')).encode()).hexdigest()


def _parent_state(path):
    path = Path(path)
    if path.is_dir():
        path = path / 'round.json'
    state = json.loads(path.read_text())
    if state.get('state') != 'complete' or state.get('state_sha256') != _state_digest(state):
        raise ValueError('parent round is not a verified completed round')
    return state


def eligible_source_frames(records, annotations, *, audit_groups=(), target_domain=None,
                           assignments=None, excluded_frame_ids=()):
    if assignments is None:
        raise ValueError('frozen assignments are required for proposal selection')
    _validate_labels(records, annotations, assignments)
    audit_groups=set(audit_groups)
    excluded_frame_ids=set(excluded_frame_ids)
    target_groups = {row.group_id for row in records if row.domain == target_domain}
    return [row for row in records if row.frame_id in annotations.frames
            and assignments[row.group_id]=='train'
            and annotations.frames[row.frame_id].status=='unreviewed'
            and row.group_id not in audit_groups | target_groups
            and row.frame_id not in excluded_frame_ids]


def verified_reviewed_exclusions(records, assignments, selection_path, labels_path,
                                 *, target_domain=None, protocol_sha256=None):
    if bool(selection_path) != bool(labels_path):
        raise ValueError('reviewed exclusion needs both selection and labels')
    if not selection_path:
        return set(), None
    selection=json.loads(Path(selection_path).read_text())
    selected=selection['train']
    if not isinstance(selected,list) or len(selected)!=len(set(selected)):
        raise ValueError('reviewed exclusion selection must contain unique training frames')
    selection_manifest_path=Path(selection_path).with_suffix('.manifest.json')
    selection_manifest_sha256=None
    if selection_manifest_path.exists():
        selection_manifest=json.loads(selection_manifest_path.read_text())
        expected_ids_sha256=hashlib.sha256(json.dumps(sorted(selected)).encode()).hexdigest()
        if (selection_manifest.get('kind')!='frozen independent source-training exclusion selection'
                or selection_manifest.get('labels_path')!=str(Path(labels_path).resolve())
                or selection_manifest.get('labels_sha256')!=file_digest(labels_path)
                or selection_manifest.get('frame_ids_sha256')!=expected_ids_sha256
                or selection_manifest.get('frames')!=len(selected)
                or selection_manifest.get('split')!='train'
                or (protocol_sha256 is not None
                    and selection_manifest.get('protocol_sha256')!=protocol_sha256)):
            raise ValueError('reviewed exclusion selection provenance manifest mismatch')
        selection_manifest_sha256=file_digest(selection_manifest_path)
    by_id={row.frame_id:row for row in records}
    labels=load_jsonl(labels_path)
    forbidden={'detector','fewshot','sam3','model','segmentation'}
    for fid in selected:
        row=by_id.get(fid)
        frame=labels.frames.get(fid)
        if (row is None or assignments.get(row.group_id)!='train'
                or (target_domain is not None and row.domain==target_domain)
                or frame is None or not is_resolved(frame,require_blind=True)
                or frame.split!='train' or frame.group_id!=row.group_id
                or frame.source_anchor_hash!=row.source_sha256
                or any(p.source.lower() in forbidden for p in frame.provenance)):
            raise ValueError(f'reviewed exclusion is not an independent source-training label: {fid}')
    manifest={'selection_sha256':file_digest(selection_path),
              'labels_sha256':file_digest(labels_path),
              'frame_ids_sha256':expected_ids_sha256 if selection_manifest_sha256 else
                  hashlib.sha256(json.dumps(sorted(selected)).encode()).hexdigest(),
              'frames':len(selected)}
    if selection_manifest_sha256:
        manifest['selection_manifest_sha256']=selection_manifest_sha256
    return set(selected), manifest


def bind_exclusion_selection(protocol, annotations_path, output):
    """Create an immutable selection bound to a frozen reviewed source-label file."""
    records,assignments,_=load_protocol(protocol)
    by_id={row.frame_id:row for row in records}
    labels=load_jsonl(annotations_path)
    _validate_labels(records,labels,assignments)
    forbidden={'detector','fewshot','sam3','model','segmentation'}
    selected=sorted(labels.frames)
    if not selected:
        raise ValueError('reviewed exclusion label file is empty')
    for fid in selected:
        row=by_id.get(fid)
        frame=labels.frames[fid]
        if (row is None or assignments.get(row.group_id)!='train'
                or frame.split!='train' or not is_resolved(frame,require_blind=True)
                or any(p.source.lower() in forbidden for p in frame.provenance)):
            raise ValueError(f'exclusion labels must be independently resolved source-training frames: {fid}')
    selection={'train':selected,'val':[],'test':[]}
    output=Path(output)
    manifest={'kind':'frozen independent source-training exclusion selection',
              'protocol_sha256':file_digest(Path(protocol)/'protocol.json'),
              'labels_path':str(Path(annotations_path).resolve()),
              'labels_sha256':file_digest(annotations_path),
              'split':'train','frames':len(selected),
              'frame_ids_sha256':hashlib.sha256(json.dumps(selected).encode()).hexdigest()}
    selection_path=output
    manifest_path=output.with_suffix('.manifest.json')
    if selection_path.exists() or manifest_path.exists():
        if (not selection_path.exists() or not manifest_path.exists()
                or json.loads(selection_path.read_text())!=selection
                or json.loads(manifest_path.read_text())!=manifest):
            raise ValueError('existing exclusion selection differs from its bound inputs')
    else:
        write_json(selection_path,selection)
        write_json(manifest_path,manifest)
    return manifest


def select_source_candidates(records, labels, assignments, *, audit_groups,
                             target_domain=None, excluded_frame_ids=(), limit=256, seed=42):
    if limit < 1:
        raise ValueError('round candidate limit must be positive')
    candidates=eligible_source_frames(records,labels,audit_groups=audit_groups,
                                     target_domain=target_domain, assignments=assignments,
                                     excluded_frame_ids=excluded_frame_ids)
    random.Random(seed).shuffle(candidates)
    return candidates[:limit]


def preselect_round(protocol, annotations_path, output, *, audit_groups,
                    exclude_reviewed_selection=None, exclude_reviewed_labels=None,
                    target_domain=None, limit=256, seed=42):
    records,assignments,_=load_protocol(protocol)
    if not audit_groups or any(assignments.get(group)!='train' for group in audit_groups):
        raise ValueError('preselection requires source-training audit groups')
    labels=load_jsonl(annotations_path)
    excluded,exclusion_manifest=verified_reviewed_exclusions(
        records,assignments,exclude_reviewed_selection,exclude_reviewed_labels,
        target_domain=target_domain,
        protocol_sha256=file_digest(Path(protocol)/'protocol.json'))
    candidates=select_source_candidates(records,labels,assignments,
        audit_groups=audit_groups,target_domain=target_domain,
        excluded_frame_ids=excluded,limit=limit,seed=seed)
    selection={'train':[row.frame_id for row in candidates],'val':[],'test':[]}
    output=Path(output)
    manifest={'protocol_sha256':file_digest(Path(protocol)/'protocol.json'),
              'input_labels_sha256':file_digest(annotations_path),
              'audit_groups':sorted(audit_groups),'reviewed_exclusion':exclusion_manifest,
              'target_domain':target_domain,'seed':seed,'limit':limit,
              'selected_frames':len(candidates)}
    if output.exists() and json.loads(output.read_text())!=selection:
        raise ValueError('existing preselection differs from frozen candidate rules')
    manifest_path=output.with_suffix('.manifest.json')
    if manifest_path.exists() and json.loads(manifest_path.read_text())!=manifest:
        raise ValueError('existing preselection manifest differs from frozen inputs')
    write_json(output,selection)
    write_json(manifest_path,manifest)
    return manifest


def propose_round(protocol, annotations_path, checkpoint, output, *, audit_groups=(),
                  target_domain=None, limit=256, seed=42, device='cuda:0',
                  round_index=1, parent_round=None,
                  exclude_reviewed_selection=None, exclude_reviewed_labels=None,
                  preselection_path=None):
    output=Path(output);output.mkdir(parents=True,exist_ok=True)
    if not audit_groups:
        raise ValueError('reserve source audit groups before fitting the teacher')
    records,assignments,identity=load_protocol(protocol)
    labels=load_jsonl(annotations_path)
    _validate_labels(records, labels, assignments)
    run=json.loads((Path(checkpoint).parent/'run.json').read_text())
    completion=json.loads((Path(checkpoint).parent/'completed.json').read_text())
    if not _is_completed(Path(checkpoint).parent,completion['target_epochs']):
        raise ValueError('teacher has not completed its registered training run')
    if file_digest(checkpoint) != completion['best_checkpoint_sha256']:
        raise ValueError('teacher checkpoint is not the completed best checkpoint')
    if run['protocol_sha256']!=file_digest(Path(protocol)/'protocol.json'):
        raise ValueError('teacher used a different data protocol')
    groups=set(run['train_groups'])
    accessed = _teacher_access(records, assignments, run, audit_groups, target_domain)
    if run['annotation_sha256']!=file_digest(annotations_path):
        raise ValueError('teacher label version and round label version differ')
    excluded, exclusion_manifest=verified_reviewed_exclusions(
        records,assignments,exclude_reviewed_selection,exclude_reviewed_labels,
        target_domain=target_domain,
        protocol_sha256=file_digest(Path(protocol)/'protocol.json'))
    candidates=select_source_candidates(records,labels,assignments,audit_groups=audit_groups,
                                        target_domain=target_domain,excluded_frame_ids=excluded,
                                        limit=limit,seed=seed)
    if preselection_path:
        preselected=json.loads(Path(preselection_path).read_text())
        if preselected.get('train')!=[row.frame_id for row in candidates]:
            raise ValueError('frozen preselection differs from teacher candidate rules')
        preselection_manifest=json.loads(Path(preselection_path).with_suffix('.manifest.json').read_text())
        if (preselection_manifest['protocol_sha256']!=file_digest(Path(protocol)/'protocol.json')
                or preselection_manifest['input_labels_sha256']!=file_digest(annotations_path)
                or preselection_manifest['reviewed_exclusion']!=exclusion_manifest
                or preselection_manifest['audit_groups']!=sorted(audit_groups)
                or preselection_manifest['target_domain']!=target_domain
                or preselection_manifest['seed']!=seed or preselection_manifest['limit']!=limit):
            raise ValueError('frozen preselection manifest differs from teacher inputs')
    record={'state':'proposing','protocol_sha256':file_digest(Path(protocol)/'protocol.json'),
            'protocol':str(Path(protocol).resolve()),
            'input_labels':str(Path(annotations_path).resolve()),
            'input_labels_sha256':file_digest(annotations_path),'teacher_sha256':file_digest(checkpoint),
            'teacher_train_groups':sorted(groups),'audit_groups':sorted(audit_groups),
            'teacher_accessed_groups':sorted(accessed), 'round_index':round_index,
            'reviewed_exclusion':exclusion_manifest,
            'preselection_sha256':file_digest(preselection_path) if preselection_path else None,
            'parent_round':str(Path(parent_round).resolve()) if parent_round else None,
            'parent_state_sha256':None,
            'target_domain':target_domain,'frame_ids':[r.frame_id for r in candidates]}
    if parent_round:
        parent = _parent_state(parent_round)
        if (round_index != parent['round_index'] + 1
                or parent['protocol_sha256'] != record['protocol_sha256']
                or parent['reviewed_labels_sha256'] != record['input_labels_sha256']
                or parent['audit_groups'] != record['audit_groups']
                or parent.get('target_domain') != target_domain):
            raise ValueError('round does not continue the same audited input/output chain')
        record['parent_state_sha256'] = parent['state_sha256']
    elif round_index != 1:
        raise ValueError('later rounds require a completed parent round')
    record['round_id'] = _state_digest(record)
    state_path=output/'round.json'
    if state_path.exists():
        previous=json.loads(state_path.read_text())
        if previous.get('round_id') != record['round_id']:
            raise ValueError('round directory belongs to a different teacher/data version')
        if previous['state'] in {'awaiting_review','complete'}:
            return previous
    write_json(state_path,record)
    model,config=load_detector_checkpoint(checkpoint)
    model.eval().to(resolve_device(device))
    saved=torch.load(checkpoint,map_location='cpu',weights_only=False)
    stats=NormalizationStats(**saved['normalization'])
    predictions=json.loads((output/'predictions.json').read_text()) if (output/'predictions.json').exists() else {}
    errors=json.loads((output/'read_errors.json').read_text()) if (output/'read_errors.json').exists() else {}
    if predictions:
        labels=load_jsonl(output/'proposals.jsonl')
    for index,row in enumerate(candidates):
        if row.frame_id in predictions or row.frame_id in errors:
            continue
        try:
            frame=load_frame(row)
        except (ValueError,OSError) as exc:
            errors[row.frame_id]={'source':str(row.pcd),'error':str(exc),'source_sha256':row.source_sha256,
                                   'status':'quarantined_read_failure_not_negative'}
            write_json(output/'read_errors.json',errors)
            continue
        image,scale,padding=letterbox_float(apply_normalization(frame,stats),config['size'])
        meta=SampleMeta(row.frame_id,frame.shape[:2],scale,padding)
        boxes=predict_boxes(model,image.unsqueeze(0).to(resolve_device(device)),meta,conf=.05,size=config['size'])
        predictions[row.frame_id]=[{'xyxy':box,'score':score} for box,score in boxes]
        merge_proposals(labels,{row.frame_id:[Box(box[0],box[1],box[2]-box[0],box[3]-box[1])
                                               for box,score in boxes if box[2]>box[0] and box[3]>box[1]]},
                        provenance=Provenance('detector',model=record['teacher_sha256'],
                                              trained_group_ids=tuple(sorted(groups)),note='proposal only'))
        if (index+1)%16==0:
            save_jsonl(labels,output/'proposals.jsonl')
            write_json(output/'predictions.json',predictions)
    save_jsonl(labels,output/'proposals.jsonl')
    write_json(output/'predictions.json',predictions)
    write_json(output/'read_errors.json',errors)
    write_json(output/'selection.json',{'train':record['frame_ids'],'val':[],'test':[]})
    record.update(state='awaiting_review',proposal_labels_sha256=file_digest(output/'proposals.jsonl'),
                  proposed_frames=len(predictions),read_errors=len(errors))
    write_json(state_path,record)
    return record


def finalize_round(round_dir, reviewed_labels, audit_report):
    round_dir=Path(round_dir)
    state=json.loads((round_dir/'round.json').read_text())
    if state.get('state') == 'complete':
        if (state.get('state_sha256') != _state_digest(state)
                or state.get('reviewed_labels_sha256') != file_digest(reviewed_labels)
                or state.get('audit_sha256') != file_digest(audit_report)):
            raise ValueError('completed round is immutable')
        return state
    if state['state'] not in {'awaiting_review', 'complete'}:
        raise ValueError('round is not ready for final review')
    if state['proposal_labels_sha256'] != file_digest(round_dir/'proposals.jsonl'):
        raise ValueError('round proposal snapshot changed')
    if state['input_labels_sha256'] != file_digest(state['input_labels']):
        raise ValueError('round input snapshot changed')
    if file_digest(Path(state['protocol'])/'protocol.json') != state['protocol_sha256']:
        raise ValueError('round protocol changed')
    records, assignments, _ = load_protocol(state['protocol'])
    if any(assignments.get(group) != 'train' for group in state['audit_groups']):
        raise ValueError('audit groups are not frozen source training')
    if state.get('parent_round'):
        parent = _parent_state(state['parent_round'])
        if (parent['state_sha256'] != state['parent_state_sha256']
                or parent['reviewed_labels_sha256'] != state['input_labels_sha256']
                or parent['round_index'] + 1 != state['round_index']):
            raise ValueError('round parent chain changed')
    before=load_jsonl(round_dir/'proposals.jsonl');after=load_jsonl(reviewed_labels)
    _validate_labels(records, after, assignments)
    for frame_id in state['frame_ids']:
        if frame_id not in after.frames or not is_resolved(after.frames[frame_id]):
            raise ValueError(f'round still has an unresolved frame: {frame_id}')
    for frame_id,frame in before.frames.items():
        if frame.split in {'val','test'} and asdict(after.frames[frame_id])!=asdict(frame):
            raise ValueError('training annotation round changed a frozen reference')
    audit=json.loads(Path(audit_report).read_text())
    if not audit.get('frame_ids') or len(audit['frame_ids']) != len(set(audit['frame_ids'])):
        raise ValueError('round completion requires actual independently reviewed audit frames')
    record_ids = {row.frame_id for row in records}
    if not set(audit['frame_ids']) <= record_ids:
        raise ValueError('audit frames are outside the frozen protocol')
    if state.get('parent_round') and sorted(audit['frame_ids']) != parent['audit_frame_ids']:
        raise ValueError('audit panel must remain fixed across rounds')
    if audit.get('round_id') != state['round_id'] or audit.get('protocol_sha256') != state['protocol_sha256']:
        raise ValueError('audit report must bind this round and protocol')
    for role in ('before','after'):
        if file_digest(audit[f'{role}_labels'])!=audit[f'{role}_labels_sha256']:
            raise ValueError('label audit snapshot fingerprint mismatch')
    if (audit['before_labels_sha256'] != state['input_labels_sha256']
            or audit['after_labels_sha256'] != file_digest(reviewed_labels)):
        raise ValueError('audit snapshots must be this round input and reviewed output')
    if audit['before_labels_sha256'] == audit['after_labels_sha256']:
        raise ValueError('audit requires fresh independent reviews, not the same snapshot')
    old_audit=load_jsonl(audit['before_labels']);new_audit=load_jsonl(audit['after_labels'])
    _validate_labels(records, old_audit, assignments)
    _validate_labels(records, new_audit, assignments)
    changed=0
    exact_changed=0
    audit_reviews = {}
    for fid in audit['frame_ids']:
        previous=old_audit.frames[fid];current=new_audit.frames[fid]
        if current.group_id not in state['audit_groups'] or previous.group_id!=current.group_id:
            raise ValueError('audit frames were not drawn from reserved source groups')
        if not is_resolved(previous,require_blind=True) or not is_resolved(current,require_blind=True):
            raise ValueError('audit snapshots require independently bound blind reviews')
        if any(p.source.lower() in {'detector','fewshot','sam3','model','segmentation'}
               for frame in (previous, current) for p in frame.provenance):
            raise ValueError('candidate-assisted audit is not an independent reference')
        if previous.source_anchor_hash!=current.source_anchor_hash:
            raise ValueError('audit source changed')
        old_ids = {review.review_id for review in previous.reviews}
        old_reviewers = {review.reviewer for review in previous.reviews}
        fresh = [review for review in current.reviews if review.review_id
                 and review.review_id not in old_ids and review.reviewer not in old_reviewers]
        if len({review.review_id for review in fresh}) != len(fresh) or not is_resolved(
                replace(current, reviews=fresh), require_blind=True):
            raise ValueError('audit requires new bound reviews from independent new reviewers')
        audit_reviews[fid] = sorted(review.review_id for review in fresh)
        changed+=_audit_changed(previous,current)
        exact_changed+=annotation_digest(previous)!=annotation_digest(current)
    rate=changed/len(audit['frame_ids'])
    state.update(state='complete',reviewed_labels_sha256=file_digest(reviewed_labels),
                 reviewed_labels=str(Path(reviewed_labels).resolve()),
                 audit_sha256=file_digest(audit_report),audit_change_rate=rate,
                 audit_exact_change_rate=exact_changed/len(audit['frame_ids']),
                 audit_change_definition='status/count/one-to-one box IoU < 0.85',
                 audit_frame_ids=sorted(audit['frame_ids']), audit_review_ids=audit_reviews)
    state['state_sha256'] = _state_digest(state)
    write_json(round_dir/'round.json',state)
    return state


def converged(round_states):
    if len(round_states) < 3:
        return False
    seen, review_ids = set(), set()
    for index, row in enumerate(round_states):
        if (row.get('state') != 'complete' or not row.get('round_id')
                or row['round_id'] in seen or row.get('round_index') != index + 1
                or row.get('state_sha256') != _state_digest(row)
                or not row.get('audit_frame_ids') or not row.get('audit_review_ids')):
            return False
        seen.add(row['round_id'])
        fresh_ids = {rid for ids in row['audit_review_ids'].values() for rid in ids}
        if not fresh_ids or fresh_ids & review_ids:
            return False
        review_ids.update(fresh_ids)
        if index:
            parent = round_states[index - 1]
            if (row.get('parent_state_sha256') != parent['state_sha256']
                    or row.get('input_labels_sha256') != parent.get('reviewed_labels_sha256')
                    or row.get('protocol_sha256') != parent.get('protocol_sha256')
                    or row.get('audit_groups') != parent.get('audit_groups')
                    or row.get('audit_frame_ids') != parent.get('audit_frame_ids')
                    or row.get('target_domain') != parent.get('target_domain')):
                return False
        elif row.get('parent_state_sha256') is not None:
            return False
    return all(row.get('audit_change_rate', 1) < .01 for row in round_states[-2:])


if __name__=='__main__':
    parser=argparse.ArgumentParser();sub=parser.add_subparsers(dest='command',required=True)
    bind=sub.add_parser('bind-exclusion');bind.add_argument('--protocol',default='outputs/protocol_v5')
    bind.add_argument('--annotations',required=True);bind.add_argument('--output',required=True)
    preselect=sub.add_parser('preselect');preselect.add_argument('--protocol',default='outputs/protocol_v5')
    preselect.add_argument('--annotations',required=True);preselect.add_argument('--output',required=True)
    preselect.add_argument('--audit-groups',required=True);preselect.add_argument('--target-domain')
    preselect.add_argument('--limit',type=int,default=256);preselect.add_argument('--seed',type=int,default=42)
    preselect.add_argument('--exclude-reviewed-selection')
    preselect.add_argument('--exclude-reviewed-labels')
    propose=sub.add_parser('propose');propose.add_argument('--protocol',default='outputs/protocol_v3')
    propose.add_argument('--annotations',required=True);propose.add_argument('--checkpoint',required=True)
    propose.add_argument('--output',required=True);propose.add_argument('--target-domain')
    propose.add_argument('--audit-groups',required=True,help='JSON list of groups excluded from teacher fitting')
    propose.add_argument('--device',default='cuda:0');propose.add_argument('--limit',type=int,default=256)
    propose.add_argument('--round-index', type=int, default=1)
    propose.add_argument('--parent-round')
    propose.add_argument('--exclude-reviewed-selection')
    propose.add_argument('--exclude-reviewed-labels')
    propose.add_argument('--preselection')
    finish=sub.add_parser('finalize');finish.add_argument('--round',required=True)
    finish.add_argument('--reviewed-labels',required=True);finish.add_argument('--audit-report',required=True)
    args=parser.parse_args()
    if args.command=='bind-exclusion':
        print(json.dumps(bind_exclusion_selection(args.protocol,args.annotations,args.output)))
    elif args.command=='preselect':
        print(json.dumps(preselect_round(args.protocol,args.annotations,args.output,
              audit_groups=json.loads(Path(args.audit_groups).read_text()),
              exclude_reviewed_selection=args.exclude_reviewed_selection,
              exclude_reviewed_labels=args.exclude_reviewed_labels,
              target_domain=args.target_domain,limit=args.limit,seed=args.seed)))
    elif args.command=='propose':
        print(json.dumps(propose_round(args.protocol,args.annotations,args.checkpoint,args.output,
              audit_groups=json.loads(Path(args.audit_groups).read_text()),target_domain=args.target_domain,
              device=args.device,limit=args.limit,round_index=args.round_index,parent_round=args.parent_round,
              exclude_reviewed_selection=args.exclude_reviewed_selection,
              exclude_reviewed_labels=args.exclude_reviewed_labels,
              preselection_path=args.preselection)))
    else:print(json.dumps(finalize_round(args.round,args.reviewed_labels,args.audit_report)))
