xc_agent_platform_demo/src/live_cycle.py

"""Queue-gated live cycles; all remote collaborators are injectable."""
import json
import os
import sys
import threading
from pathlib import Path
from .banned import banned_rule
from .config_params import GPU_ENUMS, build_config_params_with_meta
from .gate import evaluate_gate, queue_threshold
from .live_queue import read_queue, model_key
from .pending_pool import build_ordered_candidates
from .task_add_client import TaskAddClient, build_payload, resolve_token_with_source
from .ledger import load_baked, load_persisted, persist, rebuild

_submitted = set()
_cycle_lock = threading.Lock()


def run_cycle(candidates=None, client=None, queue_reader=None, now=None):
    with _cycle_lock:
        return _run_cycle(candidates, client, queue_reader, now)


def _run_cycle(candidates, client, queue_reader, now):
    decisions = []

    def emit(action, reason, **fields):
        decision = dict(action=action, reason=reason, **fields)
        decisions.append(decision)
        print('[live] ' + action + ' ' + ' '.join(f'{k}={str(v).replace(chr(10), " ").replace(chr(13), " ")}' for k, v in dict(fields, reason=reason).items()), file=sys.stderr)

    gate = evaluate_gate()
    if not gate.allowed:
        emit('hold', gate.reason)
        return decisions
    try:
        _, source = resolve_token_with_source()
    except (ValueError, OSError, UnicodeError):
        emit('hold', 'missing/invalid_token')
        return decisions
    print('[live] token source=' + source, file=sys.stderr)
    try:
        cap = int(os.environ.get('LIVE_MAX_SUBMITS_PER_CYCLE', '3'))
        if cap < 1:
            raise ValueError
    except ValueError:
        emit('hold', 'invalid_cycle_cap')
        return decisions
    if candidates is None:
        try:
            if os.environ.get('PENDING_SUBMIT_MD') or os.environ.get('PENDING_SUBMIT_TXT'):
                candidates = build_ordered_candidates()
            else:
                candidates = json.loads((Path(__file__).parent / 'data/candidates.json').read_text())
        except (OSError, ValueError, IndexError):
            emit('hold', 'candidate_read_failed')
            return decisions
    candidates = sorted(candidates, key=lambda c: (c.get('section', 'B') != 'A', c.get('foothold_class') != 'verified_reuse'))
    if not candidates:
        emit('hold', 'no_candidates')
        return decisions
    state = Path(os.environ.get('LIVE_STATE_FILE', '/tmp/live-submitted.json'))
    try:
        persisted = load_persisted(state) | _submitted
        baked, blocked = load_baked()
        known = persisted | baked
    except (OSError, ValueError, KeyError, TypeError):
        emit('hold', 'state_read_failed')
        return decisions
    reader = queue_reader or read_queue
    client = client if client is not None else TaskAddClient()
    attempts = 0
    for candidate in candidates:
        model = candidate.get('model_address') or candidate.get('modelAddress') or ''
        rule = banned_rule(model + ' ' + str(candidate.get('model_name', candidate.get('modelName', ''))))
        if rule:
            emit('skip', 'banned:' + rule, model=model)
            continue
        if not model or '<' in model or '>' in model:
            emit('skip', 'placeholder')
            continue
        key = model_key(model)
        if key in blocked:
            emit('skip', 'do-not-resubmit', model=model)
            continue
        if candidate.get('skip_reason'):
            emit('skip', 'pending_filter', model=model)
            continue
        if attempts >= cap:
            emit('hold', 'cycle_cap')
            break
        choices = candidate.get('try_next_gpus') or [candidate.get('targetGpu')]
        gpu = next((g for g in choices if g in GPU_ENUMS and (key, GPU_ENUMS[g]) not in known), None)
        if gpu is None:
            emit('skip', 'all_gpus_done_or_unmapped', model=model)
            continue
        # Rebuild remote identities before config calls and every submission.
        try:
            count, why, remote = reader()
            if type(count) is not int or count < 0:
                raise ValueError
            known.update(remote)
        except Exception:
            emit('hold', 'ledger_rebuild_failed')
            break
        gpu = next((g for g in choices if g in GPU_ENUMS and (key, GPU_ENUMS[g]) not in known), None)
        if gpu is None:
            emit('skip', 'all_gpus_done_or_unmapped', model=model)
            continue
        if count >= queue_threshold():
            emit('hold', f'queue>={queue_threshold()}', count=count)
            break
        framework = candidate.get('framework') or 'vllm'
        try:
            yaml, meta = build_config_params_with_meta(gpu, framework)
        except Exception:
            emit('skip', 'config_failed', model=model)
            continue
        payload = build_payload(model, GPU_ENUMS[gpu], framework, os.environ['STRATEGY_ID'].strip(), yaml)
        if any(not value or '<' in str(value) or '>' in str(value) for value in payload.values()):
            emit('skip', 'placeholder', model=model)
            continue
        pair = (key, GPU_ENUMS[gpu])
        known.add(pair)
        persisted.add(pair)
        _submitted.add(pair)
        try:
            persist(state, persisted)
        except OSError:
            emit('hold', 'state_write_failed')
            break
        attempts += 1
        try:
            result = client.submit(payload)
            status, code = result.get('http_status'), result.get('platform_code')
            status = status if type(status) is int else None
            code = code if type(code) is int else None
            reason = 'task_add_response' if status is not None else 'transport_error'
        except Exception:
            status, code, reason = None, None, 'submit_error'
        emit('submitted', reason, model=model, gpu=GPU_ENUMS[gpu], queue_before=count,
             http=status, code=code, **meta)
    return decisions