Datasets:
File size: 54,588 Bytes
0e239c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 | """Evaluate one submitted multi-repository candidate against frozen batch06 tests.
No gold selection, endpoint expectations, model calls, baseline/score writes,
or publication. Help/import/check-only do not access Docker or create outputs.
"""
import argparse
import collections
import datetime
import hashlib
import importlib.util
import json
import os
from pathlib import Path, PurePosixPath
import re
import shlex
import shutil
import subprocess
import sys
from types import SimpleNamespace
import uuid
sys.dont_write_bytecode = True
from batch06_candidate_case_reports_v1 import parse_report
HERE = Path(__file__).resolve().parent
DEFAULT_SUPPORT = HERE if (HERE / 'evaluate_reusable_batch06_image.py').is_file() else HERE.parents[1] / 'batch06/publication'
OWNER = 'native-candidate-batch06-v1'
SUPPORT_SHA256 = {
'evaluate_reusable_batch06_image.py': '99bfbe785ff03efa19a02c1755839847dfda57e9e5e93f52d7ff19381798a523',
'reusable_support/batch06_case_reports.py': '71be1b571260f84a250dd6c1e4689bde8d80a4f71f6926d0103e18272145f675',
'reusable_support/batch06_git_state.py': '87b2720ada6307f55e8550661ffff21267c69b547e89d254e0b82d5f2935af32',
'reusable_support/batch06_runtime_resources.py': 'f68535cdf3feeb9435129649c04020ca5361a2d86aa08359ca2dccf957ecb486',
'reusable_support/batch06_source_audit.py': 'fe8dcb35ca7d9fb28d4ddf484e17fa02a706d13aa928d392be708e6d499c12fd',
'reusable_support/batch06_source_files.py': 'a9ccfb607e04ade3d165cf14e2fc2579326d220f93539c1e09e9ce4fbe7dab95',
'reusable_support/execution_io.py': 'fca4f9c2a2fe83af2203257c1155af2db45bb065080ae47fb23378affd3cf407',
'reusable_support/image_identity.py': '82764a71a677364e7dbbe40023885ca3f15bf8f307a98dd8378bfb80966decf0',
'reusable_support/validation_policy.py': '42dee62ae6ac69fd6fecfa1e04530ad598e1b230fe3fd67e81047d9c44f067ea',
}
# Verified read-only against control/inputs/<iid>/binding.json and all bound
# current files on 2026-10-16. Image configs come from hash-verified OCI manifests
# (Conda) and the repair build metadata (Meson v2 / PNPM v2), never a mutable tag.
PROFILES = {
'buildpkg-conda-14674': {
'task_sha256': 'daf906a285d6990dd6c378ec5f3a376814c11ad4362ce620326da132ea07fe83',
'contract_sha256': '2aeef1122c363c444dd6569b5b714b12cdbe8a1059da15108fe04ab599df05f9',
'registry_digest': 'sha256:d2745804b21528b350187e18ac32ffb773faef87e28b7d6327df18d6fbc91d00',
'config_digest': 'sha256:ad74c088d5215e3dbbb9e25b2010192d1dfcbee09b4af2dc561a7e72a75a46bc'},
'buildpkg-conda-16510': {
'task_sha256': 'b30fcf076b486b203a8c4b8c22107f00f4dbdb37a812e152a9b7cfe7c6658b9f',
'contract_sha256': '3ec3d42e43282535358d0dd65693f0d2af99cc3f996316b23ea644b02e62416c',
'registry_digest': 'sha256:26d1b76d1f0c27ebd3cafb61a2d58e466f73dce534057681f46725f4e74d078d',
'config_digest': 'sha256:06eecf1a7bf9fb40a201c9a48a09a6046cbbdb93c4cc3933e88750ba700cbc94'},
'buildpkg-conda-16555': {
'task_sha256': 'c26374c00e6c0631b58ecad2f4f138a6f46c9ba5386cb255481db35b6b353d72',
'contract_sha256': '96153bfb8fb68b9392dd84e1e3aa2da614ddd0b90b2209675e41594b8907006b',
'registry_digest': 'sha256:f9442940872ee8ff677cab6e19a548a8bb1e5f7a6447b4dcc8f443e6aa03fb0b',
'config_digest': 'sha256:3137b95a0d6e3e466e5b08b8fc826db7c1dcad598b611459e6c151b3bdd0b2da'},
'buildpkg-meson-15997': {
'task_sha256': 'dbd9f3daf089cc222ffe04837a733ce08193079ed83a8aeccdfc1dd91a8bfcf0',
'contract_sha256': 'cc25cf2c67a01f65e92f91734c79dac67480e0c00479c1ea06985918a7bab5d5',
'registry_digest': 'sha256:749c9f2969287b45357c2497f8e3390fb3daa40266ed263b79319c97d03c0626',
'config_digest': 'sha256:9db08b84b4903472b10cd4d43b9c81d86dd4e3d6bae51d01a524cd3cd98da21c'},
'buildpkg-pnpm-11330': {
'task_sha256': '0043628f0223fe1d4312e94db372d2342dc2c1978591ecabde672f250ab6471b',
'contract_sha256': '425db49bef334d759f5f2c7825966042ddc0fd9d53350bcafb781f49784d4bf0',
'registry_digest': 'sha256:e6c20a1727d4eb758737a9c2710a2e0a805bc534fc056929d7ddb2279b55437c',
'config_digest': 'sha256:e3812fc8855ddd21aa20648162571a834da9c2e776157decd0a07aa7c350601c'},
}
PNPM_RESOURCE_IMAGE = 'silinchen0617/crossrepo-bench@sha256:1563086d39cbdf087f748c0e845fb33921e307e605bf639393fe552c9a271372'
PNPM_RESOURCE_MANIFEST_SHA256 = '292b80ad4a806df8e425a7ad92545534a4a7c782514e18353a2504c6e1375931'
ENVIRONMENT = {'PIP_NO_INDEX': '1', 'PIP_DISABLE_PIP_VERSION_CHECK': '1',
'PYTHONDONTWRITEBYTECODE': '1', 'PIP_NO_DEPS': '1', 'PIP_NO_BUILD_ISOLATION': '0',
'npm_config_offline': 'true', 'FORCE_COLOR': '0'}
def require(value, message):
if not value:
raise ValueError(message)
def digest(path):
h = hashlib.sha256()
with Path(path).open('rb') as stream:
for block in iter(lambda: stream.read(1024 * 1024), b''):
h.update(block)
return h.hexdigest()
def regular(path):
path = Path(path).absolute()
require(path.is_file() and not path.is_symlink() and path == path.resolve(), 'Missing or symlinked input: ' + str(path))
return path
def read_json(path):
def unique(pairs):
result = {}
for key, value in pairs:
require(key not in result, 'Duplicate JSON key: ' + key)
result[key] = value
return result
return json.loads(regular(path).read_text(), object_pairs_hook=unique,
parse_constant=lambda value: (_ for _ in ()).throw(ValueError('Invalid JSON constant: ' + value)))
def import_file(name, path):
spec = importlib.util.spec_from_file_location(name, path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
return module
def load_support(directory):
"""Load exact reviewed portable support, without running its endpoint main."""
directory = Path(directory).resolve()
for name, expected in SUPPORT_SHA256.items():
require(digest(regular(directory / name)) == expected, 'Frozen support SHA drift: ' + name)
names = ('batch06_case_reports', 'batch06_runtime_resources', 'image_identity', 'validation_policy', 'execution_io')
modules = {name: import_file('_candidate_frozen_' + name, directory / 'reusable_support' / (name + '.py')) for name in names}
previous = {name: sys.modules.get(name) for name in names}
old_path = sys.path[:]
try:
sys.modules.update(modules)
baseline = import_file('_candidate_frozen_batch06', directory / 'evaluate_reusable_batch06_image.py')
finally:
sys.path[:] = old_path
for name, module in previous.items():
if module is None:
sys.modules.pop(name, None)
else:
sys.modules[name] = module
return SimpleNamespace(root=directory, code=directory / 'reusable_support', baseline=baseline,
reports=modules['batch06_case_reports'], runtime=modules['batch06_runtime_resources'],
identity=modules['image_identity'], io=modules['execution_io'])
def safe_patch_path(name):
rel = PurePosixPath(name)
require(name and not rel.is_absolute() and '..' not in rel.parts and '.git' not in rel.parts and '\x00' not in name,
'Candidate patch escapes repository: ' + name)
return name
def git_quoted_token(data):
"""Decode Git's C-quoted path bytes, including octal UTF-8, without shlex."""
require(data.startswith(b'"'), 'Expected Git quoted path')
result = bytearray(); index = 1
escapes = {ord('a'): 7, ord('b'): 8, ord('t'): 9, ord('n'): 10,
ord('v'): 11, ord('f'): 12, ord('r'): 13, ord('\\'): 92, ord('"'): 34}
while index < len(data):
value = data[index]; index += 1
if value == 34:
return bytes(result), index
if value == 92:
require(index < len(data), 'Unterminated Git path escape')
value = data[index]; index += 1
if value in escapes:
result.append(escapes[value])
elif 48 <= value <= 55:
octal = bytes([value])
while index < len(data) and len(octal) < 3 and 48 <= data[index] <= 55:
octal += bytes([data[index]]); index += 1
number = int(octal, 8); require(number <= 255, 'Invalid Git octal path escape')
result.append(number)
else:
raise ValueError('Unsupported Git path escape')
else:
result.append(value)
raise ValueError('Unterminated Git quoted path')
def git_single_path(data, *, unified=False):
# Git emits one empty timestamp delimiter after space-bearing ---/+++ paths.
if unified and data.endswith(b'\t'):
data = data[:-1]
if data.startswith(b'"'):
path, end = git_quoted_token(data)
require(end == len(data), 'Extra data after Git quoted path')
else:
require(b'\t' not in data, 'Unsupported timestamp/tab in unquoted Git header path')
path = data
return path.decode('utf-8', errors='surrogateescape')
def git_header_pairs(data):
if data.startswith(b'"'):
old, end = git_quoted_token(data)
require(data[end:end + 1] == b' ', 'Missing Git path separator')
return [(old.decode('utf-8', errors='surrogateescape'), git_single_path(data[end + 1:]))]
pairs = []
for index, value in enumerate(data):
if value == 32 and (data[index + 1:].startswith(b'b/') or data[index + 1:].startswith(b'"b/')):
try:
pairs.append((git_single_path(data[:index]), git_single_path(data[index + 1:])))
except ValueError:
continue
require(pairs, 'Cannot decode both Git diff header paths')
return pairs
def validate_patch_headers(data, numstat_paths):
"""Bind BOTH sides of every Git/rename/copy/unified header to Git numstat.
Supported input is standard `git diff` (including binary, rename/copy,
mode-only and C-quoted paths). Bare traditional/combined/ambiguous formats
are explicitly unsupported rather than guessing their path semantics.
"""
lines = data.split(b'\n')
require(not any(line.startswith((b'diff --cc ', b'diff --combined ')) for line in lines), 'Combined Git diffs are unsupported')
starts = [index for index, line in enumerate(lines) if line.startswith(b'diff --git ')]
require(starts, 'Only standard git diff patches are supported; bare unified diffs are unsupported')
require(not any(line.startswith((b'--- ', b'+++ ', b'rename from ', b'copy from ')) for line in lines[:starts[0]]),
'Path header outside a Git diff block')
expected_numstat = []; inventory = []
for position, start in enumerate(starts):
end = starts[position + 1] if position + 1 < len(starts) else len(lines)
metadata = {}; operation = 'change'
for line in lines[start + 1:end]:
if line.startswith((b'@@', b'GIT binary patch')):
break # Hunk content may itself start with ---/+++; not metadata.
require(not line.startswith(b'Binary files '), 'Binary diffs require git diff --binary')
for prefix, key in ((b'--- ', 'old'), (b'+++ ', 'new'), (b'rename from ', 'rename_old'),
(b'rename to ', 'rename_new'), (b'copy from ', 'copy_old'), (b'copy to ', 'copy_new')):
if line.startswith(prefix):
require(key not in metadata, 'Duplicate Git path header: ' + key)
value = git_single_path(line[len(prefix):], unified=key in ('old', 'new'))
if key in ('old', 'new'):
if value == '/dev/null':
value = None
else:
side = 'a/' if key == 'old' else 'b/'
require(value.startswith(side), 'Unsupported Git unified path prefix')
value = safe_patch_path(value[2:])
else:
value = safe_patch_path(value)
metadata[key] = value
break
bound = None
for kind in ('rename', 'copy'):
if kind + '_old' in metadata or kind + '_new' in metadata:
require(bound is None and kind + '_old' in metadata and kind + '_new' in metadata,
'Incomplete/conflicting Git rename/copy headers')
bound = (metadata[kind + '_old'], metadata[kind + '_new']); operation = kind
if 'old' in metadata or 'new' in metadata:
require('old' in metadata and 'new' in metadata, 'Incomplete Git unified path headers')
old, new = metadata['old'], metadata['new']
require(old is not None or new is not None, 'Two null Git paths')
marker_pair = (old if old is not None else new, new if new is not None else old)
require(bound is None or marker_pair == bound, 'Git rename/copy and unified headers disagree')
bound = marker_pair
if old is None: operation = 'create'
elif new is None: operation = 'delete'
candidates = []
for old, new in git_header_pairs(lines[start][len(b'diff --git '):]):
if old.startswith('a/') and new.startswith('b/'):
pair = (old[2:], new[2:])
if (bound is not None and pair == bound) or (bound is None and pair[0] == pair[1]):
candidates.append(pair)
require(len(candidates) == 1, 'Ambiguous or inconsistent Git diff header paths')
old, new = (safe_patch_path(value) for value in candidates[0])
expected_numstat.append(old if operation == 'delete' else new)
inventory.append({'old_path': old, 'new_path': new, 'operation': operation})
require(collections.Counter(expected_numstat) == collections.Counter(numstat_paths),
'Git numstat and full path-header inventories disagree')
return inventory
def validate_candidate_patches(task, mapping_file):
"""Read patch paths and use Git's read-only numstat parser for decoded paths."""
mapping_file = regular(mapping_file)
mapping = read_json(mapping_file)
require(isinstance(mapping, dict), 'Candidate mapping must be a JSON object')
keys = {repo['key'] for repo in task['repositories']}
require(set(mapping).issubset(keys), 'Unknown candidate repository key')
result = {}
for key, value in mapping.items():
require(isinstance(value, str) and value, 'Candidate patch path must be a nonempty string')
supplied = Path(value)
path = regular(supplied if supplied.is_absolute() else mapping_file.parent / supplied)
data = path.read_bytes()
require(data, 'Empty candidate patch file; omit an unchanged repository')
argv = ['git', 'apply', '--numstat', '-z', '--']
parsed = subprocess.run(argv, input=data, capture_output=True, timeout=30,
env={**os.environ, 'GIT_CONFIG_NOSYSTEM': '1', 'GIT_CONFIG_GLOBAL': os.devnull})
require(parsed.returncode == 0 and parsed.stdout, 'Invalid candidate patch: ' + parsed.stderr.decode(errors='replace'))
paths = []
for row in parsed.stdout.split(b'\0'):
if not row:
continue
fields = row.split(b'\t', 2)
require(len(fields) == 3, 'Malformed Git patch path inventory')
name = fields[2].decode('utf-8', errors='surrogateescape')
paths.append(safe_patch_path(name))
require(paths, 'Candidate patch has no changed repository paths')
header_paths = validate_patch_headers(data, paths)
result[key] = {'path': str(path), 'sha256': hashlib.sha256(data).hexdigest(), 'bytes': len(data),
'changed_paths': paths, 'validated_header_paths': header_paths, 'validation': {'argv': argv, 'returncode': parsed.returncode,
'stdout_sha256': hashlib.sha256(parsed.stdout).hexdigest(),
'stderr_sha256': hashlib.sha256(parsed.stderr).hexdigest()}}
return result
def prepare_inputs(bench_root, iid, mapping_file, output_dir, support_dir=DEFAULT_SUPPORT, evaluator_resource_dir=None):
require(iid in PROFILES, 'Unsupported candidate instance')
bench_root = Path(bench_root).resolve()
out = Path(output_dir).absolute()
require(out == out.resolve() and not out.exists(), 'Output must be a new non-symlink path')
require(not out.is_relative_to(bench_root), 'Output must be outside the release checkout')
support = load_support(support_dir)
support.baseline.ROOT = bench_root
inp = bench_root / 'instances' / iid
profile = PROFILES[iid]
require(digest(regular(inp / 'task.json')) == profile['task_sha256'], 'Frozen task SHA drift')
task = read_json(inp / 'task.json')
contract_path = support.baseline.checked_reference(inp, task['evaluation'])
require(digest(contract_path) == profile['contract_sha256'], 'Frozen contract SHA drift')
# Reuse the exact published loader and its checked_reference/source/resource checks.
inp, task, contract, image, resource = support.baseline.load_inputs(iid)
regular(bench_root / 'environments' / iid / 'image.json')
if iid == 'buildpkg-pnpm-11330':
require(resource['image_ref'] == PNPM_RESOURCE_IMAGE and
resource['manifest_sha256'] == PNPM_RESOURCE_MANIFEST_SHA256, 'Original PNPM runtime image/manifest binding changed')
for key, expected in profile.items():
require(image.get(key) == expected, 'Unsupported image/input profile: ' + key)
require(image.get('amd64_manifest_digest') == profile['registry_digest'], 'Unreviewed image manifest')
require(image['image_ref'] == 'silinchen0617/crossrepo-bench@' + profile['registry_digest'], 'Unapproved image reference')
repositories = {repo['key']: repo for repo in task['repositories']}
require(len(repositories) == len(task['repositories']) == 2, 'Expected two distinct repositories')
require(collections.Counter(command['repository'] for command in contract['commands']) == collections.Counter(repositories.keys()),
'Frozen command repository inventory mismatch')
for command in contract['commands']:
require(command['container_path'] == repositories[command['repository']]['container_path'], 'Command source path mismatch')
require(all(isinstance(command[kind], str) and command[kind] for kind in ('pass_to_pass', 'fail_to_pass')), 'Missing frozen command')
for artifact in contract.get('test_files', []):
support.baseline.checked_reference(inp, artifact)
rel = PurePosixPath(artifact.get('original_path', Path(artifact['path']).name))
require(not rel.is_absolute() and '..' not in rel.parts, 'Escaping evaluator injection path')
for repo in repositories.values():
for ref in repo['test_patches']:
support.baseline.checked_reference(inp, ref)
provided = Path(evaluator_resource_dir).absolute() if evaluator_resource_dir is not None else None
if provided is not None:
require(provided == provided.resolve() and not provided.is_symlink(), 'Symlinked evaluator resource directory')
if resource is None:
require(provided is None, 'This instance has no evaluator resource')
elif provided is not None:
support.runtime.verify_runtime_files(provided, resource)
patches = validate_candidate_patches(task, mapping_file)
source = support.baseline.checked_reference(bench_root / 'environments' / iid, image['source_manifest'], read_json=True)
input_files = {'task': inp / 'task.json', 'contract': inp / task['evaluation']['path'],
'image': bench_root / 'environments' / iid / 'image.json',
'source_manifest': support.baseline.checked_reference(bench_root / 'environments' / iid, image['source_manifest'])}
provenance = {'bench_root': str(bench_root), 'output_dir': str(out),
**{key: {'path': str(regular(path)), 'bytes': path.stat().st_size, 'sha256': digest(path)}
for key, path in input_files.items()}}
return {'iid': iid, 'bench_root': bench_root, 'inp': inp, 'task': task, 'contract': contract, 'image': image,
'resource': resource, 'provided_resource': provided, 'source': source, 'support': support,
'patches': patches, 'mapping_file': regular(mapping_file), 'out': out,
'image_json_sha256': digest(bench_root / 'environments' / iid / 'image.json'),
'mapping_sha256': digest(mapping_file), 'input_provenance': provenance}
def validate_git_state(task, state, label, *, expected=None, clean=False):
"""Validate the unchanged helper's tracked HEAD/diff report for both roots.
The staged report includes candidate + frozen test patch changes. Frozen
setup may create ignored/untracked build/install outputs; those are not in
git diff HEAD. No equality of staged/pre-test source-file inventories is
imposed. The tracked diff and base HEAD must remain unchanged by setup/tests.
"""
roots = {repo['container_path']: repo['base_commit'] for repo in task['repositories']}
require(isinstance(state, dict) and set(state) == set(roots), 'Git ' + label + ': paired root inventory mismatch')
for root, base in roots.items():
row = state[root]
require(isinstance(row, dict) and set(row) == {'head', 'diff_sha256'}, 'Git ' + label + ': malformed state schema')
require(isinstance(row['head'], str) and re.fullmatch('[0-9a-f]{40}', row['head']) and row['head'] == base,
'Git ' + label + ': HEAD differs from frozen base: ' + root)
require(isinstance(row['diff_sha256'], str) and re.fullmatch('[0-9a-f]{64}', row['diff_sha256']),
'Git ' + label + ': malformed tracked diff SHA: ' + root)
if clean:
require(row['diff_sha256'] == hashlib.sha256(b'').hexdigest(), 'Git ' + label + ': base tracked diff is not empty')
if expected is not None:
require(state == expected, 'Git ' + label + ': tracked candidate/test source state changed')
return state
def classify(commands, repository_keys):
expected = {(repo, kind) for repo in repository_keys for kind in ('pass_to_pass', 'fail_to_pass')}
actual = [(row['repository'], row['kind']) for row in commands]
issues = [str(issue) for row in commands for issue in row.get('issues', [])]
if len(actual) != len(expected) or set(actual) != expected or any(not row.get('cases') for row in commands):
issues.append('Incomplete candidate command/case inventory')
regressions = []
p2p_total = f2p_total = f2p_passed = 0
for command in commands:
cases = command.get('cases', [])
if command['kind'] == 'pass_to_pass':
p2p_total += len(cases)
regressions.extend({'repository': command['repository'], 'kind': command['kind'], **row}
for row in cases if not row['passed'])
else:
f2p_total += len(cases); f2p_passed += sum(row['passed'] for row in cases)
state = ('EVALUATION_ERROR' if issues else 'P2P_REGRESSION' if regressions else
'RESOLVED' if f2p_total and f2p_passed == f2p_total else 'UNRESOLVED')
return {'state': state, 'resolved': state == 'RESOLVED', 'issues': issues, 'p2p_total': p2p_total,
'p2p_regressions': regressions, 'f2p_total': f2p_total, 'f2p_passed': f2p_passed,
'f2p_failed': f2p_total - f2p_passed}
class Runner:
"""Execute first; remember raw results before best-effort receipt writes."""
def invoke(self, argv, *, input_bytes, timeout, target):
return subprocess.run(argv, input=input_bytes, capture_output=True, timeout=timeout)
def run(self, argv, target, timeout=180, check=True, input_bytes=None, on_result=None):
started = datetime.datetime.now(datetime.timezone.utc).isoformat()
timed_out = False
try:
result = self.invoke(argv, input_bytes=input_bytes, timeout=timeout, target=Path(target))
stdout, stderr, rc = result.stdout, result.stderr, result.returncode
timed_out = bool(getattr(result, 'timed_out', False))
except subprocess.TimeoutExpired as exc:
stdout, stderr, rc = exc.stdout or b'', exc.stderr or b'', -9
timed_out = True
except OSError as exc:
stdout, stderr, rc = b'', (type(exc).__name__ + ': ' + str(exc)).encode(), 127
target = Path(target)
record = {'argv': argv, 'returncode': rc, 'timed_out': timed_out, 'timeout_seconds': timeout,
'started_utc': started, 'ended_utc': datetime.datetime.now(datetime.timezone.utc).isoformat(),
'stdout_sha256': hashlib.sha256(stdout).hexdigest(), 'stderr_sha256': hashlib.sha256(stderr).hexdigest(),
'persistence_errors': []}
if input_bytes is not None:
record['stdin_sha256'] = hashlib.sha256(input_bytes).hexdigest()
# The caller records full IDs/ownership and raw streams before any I/O.
if on_result is not None:
on_result(record, stdout, stderr)
for suffix, data in (('.stdout.log', stdout), ('.stderr.log', stderr)):
try:
target.with_suffix(suffix).write_bytes(data)
except Exception as exc:
record['persistence_errors'].append(suffix + ': ' + type(exc).__name__ + ': ' + str(exc))
try:
atomic_write(target.with_suffix('.execution.json'), record)
except Exception as exc:
record['persistence_errors'].append('.execution.json: ' + type(exc).__name__ + ': ' + str(exc))
if check and (rc or timed_out or record['persistence_errors']):
raise RuntimeError(target.name + ': ' + ('timeout' if timed_out else 'exit ' + str(rc)) +
('; receipt persistence failed' if record['persistence_errors'] else ''))
return record
def atomic_write(path, value):
path = Path(path)
temporary = path.with_suffix(path.suffix + '.tmp')
with temporary.open('w') as stream:
json.dump(value, stream, indent=2, sort_keys=True); stream.write('\n'); stream.flush(); os.fsync(stream.fileno())
temporary.replace(path)
def observe_host_resources(output_directory):
"""Read Linux host availability; an unreadable/ambiguous observation fails closed."""
raw = Path('/proc/meminfo').read_bytes()
available = [re.fullmatch(rb'MemAvailable:[ \t]+([0-9]+)[ \t]+kB', line)
for line in raw.splitlines() if line.startswith(b'MemAvailable:')]
require(len(available) == 1 and available[0] is not None, 'Expected exactly one Linux MemAvailable kB value')
free = shutil.disk_usage(output_directory).free
require(type(free) is int and free >= 0, 'Invalid host disk free bytes')
return {'meminfo_raw': raw, 'memory_available_bytes': int(available[0].group(1)) * 1024,
'disk_free_bytes': free}
def record_pnpm_host_admission(cell):
"""Persist actual host evidence immediately before the PNPM candidate create."""
observed = observe_host_resources(cell)
minimum_memory = 80_000_000_000
disk_floor = 35_000_000_000
disk_margin = 256 * 1024**2
admitted = (observed['memory_available_bytes'] >= minimum_memory and
observed['disk_free_bytes'] >= disk_floor + disk_margin)
raw = observed['meminfo_raw']
(cell / 'host-meminfo.txt').write_bytes(raw)
receipt = {'schema_version': 1, 'resource_only_revision': 'pnpm11330-mem64-a01',
'state': 'ADMITTED' if admitted else 'INSUFFICIENT_HOST_RESOURCES', 'admitted': admitted,
'observed_utc': datetime.datetime.now(datetime.timezone.utc).isoformat(),
'meminfo': {'source': '/proc/meminfo', 'path': 'candidate/host-meminfo.txt',
'bytes': len(raw), 'sha256': hashlib.sha256(raw).hexdigest()},
'disk_path': str(cell.resolve()),
'observed': {key: observed[key] for key in ('memory_available_bytes', 'disk_free_bytes')},
'required': {'memory_available_bytes': minimum_memory, 'disk_free_bytes': disk_floor + disk_margin,
'disk_floor_bytes': disk_floor, 'disk_margin_bytes': disk_margin},
'container_profile': {'cpus': '8', 'memory': '64g', 'memory_swap': '64g'}}
atomic_write(cell / 'host-resource-admission.json', receipt)
return receipt
def evaluate(prepared, runner=None):
"""One fresh candidate container; dependency injection is for offline traces."""
p = prepared; runner = runner or Runner(); out = p['out']; out.mkdir(parents=True, exist_ok=False)
support = p['support']; task = p['task']; contract = p['contract']; image = p['image']; iid = p['iid']
cell = out / 'candidate'; cell.mkdir()
nonce = uuid.uuid4().hex
name = 'crossswe-candidate-' + iid + '-' + nonce
status = {'schema_version': 1, 'adapter': OWNER, 'instance_id': iid, 'world': 'candidate', 'repeat': 1,
'state': 'RUNNING', 'complete_case_inventory': False,
'image_digest': image['registry_digest'], 'config_digest': image['config_digest'],
'task_sha256': image['task_sha256'], 'contract_sha256': image['contract_sha256'],
'started_utc': datetime.datetime.now(datetime.timezone.utc).isoformat(),
'image': image, 'image_json_sha256': p['image_json_sha256'], 'source_manifest': p['source'],
'support_sha256': SUPPORT_SHA256,
'operator_sha256': {name: digest(HERE / name) for name in
('evaluate_candidate_batch06_v1.py', 'batch06_candidate_case_reports_v1.py')},
'input_provenance': p['input_provenance'], 'model_calls': 0, 'score_writes': 0, 'baseline_writes': 0,
'candidate_inputs': p['patches'],
'candidate_mapping': {'path': str(p['mapping_file']), 'sha256': p['mapping_sha256']},
'patches': [], 'commands': [], 'git_captures': {}, 'issues': [], 'logging_errors': [], 'ownership_errors': [], 'cleanup': {'attempted': False, 'removed': False},
'container_name': name, 'ownership_nonce': nonce}
cid = None; identity = None; environments = {}; setup_started = False; create_attempted = False
memory = {}; owner_confirmed = False
def fail(message):
status.setdefault('primary_error', message)
if message not in status['issues']:
status['issues'].append(message)
status['state'] = 'EVALUATION_ERROR'; status['resolved'] = False; status['complete_case_inventory'] = False
def logging_error(message):
status['logging_errors'].append(message)
fail('Receipt persistence: ' + message)
def persist_status(label, strict=True):
try:
atomic_write(out / 'status.json', status)
return True
except Exception as exc:
logging_error(label + ': ' + type(exc).__name__ + ': ' + str(exc))
if strict:
raise RuntimeError(label + ': status receipt persistence failed') from exc
return False
def observe(label, argv, record, stdout, stderr):
nonlocal cid, identity, owner_confirmed
memory[label] = {'record': record, 'stdout': stdout, 'stderr': stderr}
if record['returncode'] or record.get('timed_out'):
return
try:
if argv[:3] == ['docker', 'image', 'inspect']:
actual = json.loads(stdout)[0]
support.identity.validate_image(actual, image)
identity = actual; status['engine_image_identity'] = actual
elif argv[:2] == ['docker', 'create']:
value = stdout.decode().strip()
require(re.fullmatch('[0-9a-f]{64}', value), 'Docker create did not return a full immutable container ID')
cid = value; status['container_id'] = cid
elif argv[:2] == ['docker', 'inspect'] and label != 'removed-container-inspect':
actual = json.loads(stdout)[0]
labels = actual['Config'].get('Labels') or {}
require(identity is not None and re.fullmatch('[0-9a-f]{64}', actual['Id']) and
(cid is None or actual['Id'] == cid) and actual['Image'] == identity['Id'] and
labels.get('crossswe.owner') == OWNER and labels.get('crossswe.attempt') == nonce and
labels.get('crossswe.instance') == iid, 'Container ownership mismatch; refusing to operate/clean up')
cid = actual['Id']; status['container_id'] = cid; owner_confirmed = True
status['last_ownership_proof'] = {'label': label, 'container_id': cid, 'image_id': actual['Image'],
'labels': labels, 'stdout_sha256': record['stdout_sha256']}
except Exception as exc:
record['observation_error'] = type(exc).__name__ + ': ' + str(exc)
if argv[:2] == ['docker', 'inspect']:
status['ownership_errors'].append(record['observation_error'])
owner_confirmed = False
fail(label + ': ' + record['observation_error'])
def run(argv, label, check=True, tolerate_logging=False, **kwargs):
nonlocal owner_confirmed
if argv[:2] == ['docker', 'inspect'] and label != 'removed-container-inspect':
owner_confirmed = False
record = runner.run(argv, cell / label, check=False,
on_result=lambda row, stdout, stderr: observe(label, argv, row, stdout, stderr), **kwargs)
for error in record.get('persistence_errors', []):
logging_error(label + ': ' + error)
if record.get('observation_error'):
if not tolerate_logging:
raise RuntimeError(label + ': ' + record['observation_error'])
if record.get('persistence_errors') and not tolerate_logging:
raise RuntimeError(label + ': receipt persistence failed')
if check and (record['returncode'] or record.get('timed_out')):
raise RuntimeError(label + ': ' + ('timeout' if record.get('timed_out') else 'exit ' + str(record['returncode'])))
return record
def read_output(label):
return memory[label]['stdout']
def execute(command, label, cwd='/testbed', env=None, check=True, timeout=14400, tolerate_logging=False):
argv = ['docker', 'exec', '-w', cwd]
for key, value in (env or {}).items():
argv += ['-e', key + '=' + value]
return run(argv + [cid, 'bash', '-lc', command], label, check=check, timeout=timeout, tolerate_logging=tolerate_logging)
def capture(script, label, filename):
data = (support.code / script).read_bytes()
require(hashlib.sha256(data).hexdigest() == SUPPORT_SHA256['reusable_support/' + script], 'Support changed during execution')
result = run(['docker', 'exec', '-i', cid, 'python3', '-'], label, input_bytes=data, timeout=300)
if script == 'batch06_git_state.py':
try:
state = support.reports.decode(read_output(label).decode('utf-8', errors='strict'))
expected = None
if label == 'git-before':
expected = status['git_captures']['staged-git-state']['state']
elif label.endswith('-git-after'):
expected = status['git_captures']['git-before']['state']
validate_git_state(task, state, label, expected=expected, clean=label == 'base-git-state')
status['git_captures'][label] = {'state': state, 'stdout_sha256': result['stdout_sha256']}
except Exception as exc:
raise ValueError('Git capture ' + label + ': ' + str(exc)) from exc
try:
(cell / filename).write_bytes(read_output(label))
except Exception as exc:
logging_error(label + ': ' + filename + ': ' + type(exc).__name__ + ': ' + str(exc))
raise
def inspect(label, tolerate_logging=False):
record = run(['docker', 'inspect', cid], label, check=False, tolerate_logging=tolerate_logging)
require(record['returncode'] == 0 and not record.get('timed_out') and owner_confirmed and
not status['ownership_errors'], 'Owned container inspection failed or ownership is blocked')
return json.loads(read_output(label))[0]
try:
persist_status('initial')
# Snapshot every submitted patch before Docker, then apply this immutable
# copy. Frozen artifacts are checked again at the point of injection.
require(digest(regular(p['bench_root'] / 'environments' / iid / 'image.json')) == p['image_json_sha256'], 'Image descriptor SHA drift after preparation')
require(digest(regular(p['inp'] / 'task.json')) == image['task_sha256'], 'Frozen task SHA drift after preparation')
require(digest(regular(p['inp'] / task['evaluation']['path'])) == image['contract_sha256'], 'Frozen contract SHA drift after preparation')
require(digest(regular(p['mapping_file'])) == p['mapping_sha256'], 'Candidate mapping SHA drift after preparation')
snapshots = out / 'candidate-inputs'; snapshots.mkdir()
(snapshots / 'patches.json').write_bytes(p['mapping_file'].read_bytes())
for key, patch in p['patches'].items():
require(digest(regular(patch['path'])) == patch['sha256'], 'Candidate patch SHA drift')
snapshot = snapshots / (key + '.patch'); snapshot.write_bytes(Path(patch['path']).read_bytes())
require(digest(snapshot) == patch['sha256'], 'Candidate patch changed while snapshotting')
run(['docker', 'pull', '--platform', 'linux/amd64', image['image_ref']], 'image-pull', timeout=1800)
run(['docker', 'image', 'inspect', image['image_ref']], 'image-inspect')
identity = json.loads(read_output('image-inspect'))[0]; support.identity.validate_image(identity, image)
status['engine_image_identity'] = identity
assets = support.runtime.materialize_runtime(p['resource'], out / 'evaluator-resources', p['provided_resource'])
if p['resource'] is not None:
status['resource_materialization'] = {
'mode': 'provided-verified-directory' if p['provided_resource'] is not None else 'pinned-helper-managed-private-image',
'provided_dir': str(p['provided_resource']) if p['provided_resource'] is not None else None,
'helper_sha256': SUPPORT_SHA256['reusable_support/batch06_runtime_resources.py'],
'default_resource_container_commands_logged': False,
'verified_files': [{'path': str(path.relative_to(out)), 'bytes': path.stat().st_size, 'sha256': digest(path)}
for path in sorted(assets.rglob('*')) if path.is_file()]}
persist_status('resource-materialization')
cpus, memory_limit = ('8', '64g') if iid == 'buildpkg-pnpm-11330' else ('2', '3g')
if iid == 'buildpkg-pnpm-11330':
status['host_resource_admission'] = record_pnpm_host_admission(cell)
persist_status('host-resource-admission')
require(status['host_resource_admission']['admitted'], 'Insufficient host resources for PNPM 64GiB candidate')
create_attempted = True
run(['docker', 'create', '--name', name, '--network', 'none', '--cpus', cpus, '--memory', memory_limit,
'--memory-swap', memory_limit, '--label', 'crossswe.owner=' + OWNER, '--label', 'crossswe.attempt=' + nonce,
'--label', 'crossswe.instance=' + iid, image['image_ref'], 'sleep', 'infinity'], 'create')
cid = read_output('create').decode().strip()
require(re.fullmatch('[0-9a-f]{64}', cid), 'Docker create did not return a full immutable container ID')
status['container_id'] = cid
run(['docker', 'start', cid], 'start')
info = inspect('initial-container-inspect')
require(not info['Mounts'] and info['HostConfig']['NetworkMode'] == 'none', 'Container isolation mismatch')
require(info['HostConfig']['NanoCpus'] == int(cpus) * 10**9 and
info['HostConfig']['Memory'] == int(memory_limit[:-1]) * 1024**3 and
info['HostConfig']['MemorySwap'] == info['HostConfig']['Memory'], 'Container resource budget mismatch')
status['container_isolation'] = {'mounts': info['Mounts'], 'network': info['HostConfig']['NetworkMode'],
'cpus': cpus, 'memory': memory_limit}
capture('batch06_source_audit.py', 'base-source-audit', 'agent-source-audit.json')
audited = json.loads((cell / 'agent-source-audit.json').read_text())['manifest']
support.baseline.validate_source_manifest(audited, task)
require(audited == p['source'], 'Agent source manifest differs from published image binding')
capture('batch06_git_state.py', 'base-git-state', 'git-state-base.json')
# All caller candidates precede every frozen test patch and hidden file.
for repo in task['repositories']:
execute('git diff --exit-code HEAD && test -z "$(git status --porcelain)"', repo['key'] + '-clean', repo['container_path'])
for repo in task['repositories']:
key = repo['key']; patch = p['patches'].get(key)
if patch is None:
continue
snapshot = snapshots / (key + '.patch'); dst = '/tmp/crossswe-candidate-' + key + '.patch'
run(['docker', 'cp', str(snapshot), cid + ':' + dst], key + '-candidate-copy')
execution = execute('git apply --check ' + shlex.quote(dst) + ' && git apply ' + shlex.quote(dst), key + '-candidate-apply', repo['container_path'])
status['patches'].append({'repository': key, 'kind': 'candidate', **patch, 'snapshot': str(snapshot.relative_to(out)),
'container_path': dst, 'application': execution})
for repo in task['repositories']:
for index, patch in enumerate(repo['test_patches'], 1):
source = support.baseline.checked_reference(p['inp'], patch)
dst = '/tmp/crossswe-frozen-test-' + repo['key'] + '-' + str(index) + '.patch'
label = repo['key'] + '-frozen-test-' + str(index)
run(['docker', 'cp', str(source), cid + ':' + dst], label + '-copy')
execution = execute('git apply --check ' + shlex.quote(dst) + ' && git apply ' + shlex.quote(dst), label + '-apply', repo['container_path'])
status['patches'].append({'repository': repo['key'], 'kind': 'frozen_test', **patch, 'application': execution})
capture('batch06_source_files.py', 'staged-source', 'source-files-staged.json')
capture('batch06_git_state.py', 'staged-git-state', 'git-state-staged.json')
execute('mkdir -p /crossrepo-patches /artifacts', 'evaluator-dirs')
for number, artifact in enumerate(contract.get('test_files', [])):
source = support.baseline.checked_reference(p['inp'], artifact)
rel = PurePosixPath(artifact.get('original_path', source.name))
execute('mkdir -p ' + shlex.quote('/crossrepo-patches/' + str(rel.parent)), 'evaluator-parent-' + str(number))
run(['docker', 'cp', str(source), cid + ':/crossrepo-patches/' + str(rel)], 'inject-' + str(number))
if p['resource'] is not None:
support.runtime.verify_runtime_files(assets, p['resource'])
for number, mapping in enumerate(p['resource']['injections']):
source = assets / mapping['source']; require(source.is_dir() and not source.is_symlink(), 'Missing runtime injection')
execute('mkdir -p ' + shlex.quote(str(PurePosixPath(mapping['destination']).parent)), 'runtime-parent-' + str(number))
run(['docker', 'cp', str(source), cid + ':' + mapping['destination']], 'runtime-copy-' + str(number))
status['evaluator_resource'] = p['resource']
commands = contract['commands']
environments = {command['repository']: {**ENVIRONMENT, **command.get('environment', {})} for command in commands}
setup_started = True
for command in sorted(commands, key=lambda row: row.get('setup_order') or 0):
if command.get('setup_command'):
execute(command['setup_command'], command['repository'] + '-source-setup', command['container_path'], environments[command['repository']])
for command in sorted(commands, key=lambda row: row.get('evaluation_setup_order') or 0):
if command.get('evaluation_setup_command'):
execute(command['evaluation_setup_command'], command['repository'] + '-evaluator-setup',
command.get('evaluation_setup_cwd') or command['container_path'], environments[command['repository']])
for command in commands:
if command.get('evaluation_ready_command'):
execute(command['evaluation_ready_command'], command['repository'] + '-ready', command['container_path'], environments[command['repository']])
capture('batch06_source_files.py', 'source-before', 'source-files.json')
capture('batch06_git_state.py', 'git-before', 'git-state.json')
for command in commands:
for kind in ('pass_to_pass', 'fail_to_pass'):
label = command['repository'] + '-' + kind
execution = execute(command[kind], label, command.get('test_cwd') or command['container_path'],
environments[command['repository']], check=False)
native = cell / 'native-artifacts'; native.mkdir(exist_ok=True)
run(['docker', 'cp', cid + ':/artifacts/.', str(native)], label + '-capture-native-artifacts')
capture('batch06_source_files.py', label + '-source-after', 'source-files-after.json')
capture('batch06_git_state.py', label + '-git-after', 'git-state-after.json')
stdout = read_output(label).decode('utf-8', errors='strict')
stderr = memory[label]['stderr'].decode('utf-8', errors='strict')
rows, issues, metadata = parse_report(iid, command['repository'], kind, stdout, stderr,
execution['returncode'], cell, frozen=support.reports)
if execution.get('timed_out'):
issues.append('Native command timed out')
status['commands'].append({'repository': command['repository'], 'kind': kind, 'command': command[kind],
'cwd': command.get('test_cwd') or command['container_path'], 'environment': environments[command['repository']],
'returncode': execution['returncode'], 'passed': sum(row['passed'] for row in rows),
'failed': sum(not row['passed'] for row in rows), 'cases': rows, 'issues': issues,
'report_metadata': metadata, 'raw_receipt': str((cell / (label + '.execution.json')).relative_to(out))})
persist_status(label)
if execution.get('timed_out'):
raise RuntimeError('Native command timed out; stop before dispatching another command')
outcome = classify(status['commands'], [repo['key'] for repo in task['repositories']])
status.update({key: value for key, value in outcome.items() if key != 'state'})
if outcome['issues']:
status.setdefault('primary_error', outcome['issues'][0])
status['candidate_outcome'] = outcome['state']
status['complete_case_inventory'] = outcome['state'] != 'EVALUATION_ERROR'
status['state'] = 'VALID_CANDIDATE_EVALUATION' if status['complete_case_inventory'] else 'EVALUATION_ERROR'
status['p2p'] = {'total': outcome['p2p_total'], 'passed': outcome['p2p_total'] - len(outcome['p2p_regressions']),
'failed': len(outcome['p2p_regressions']), 'regressions': outcome['p2p_regressions']}
status['f2p'] = {'total': outcome['f2p_total'], 'passed': outcome['f2p_passed'], 'failed': outcome['f2p_failed']}
except Exception as exc:
fail(type(exc).__name__ + ': ' + str(exc))
finally:
if create_attempted and cid is None and identity and not status['ownership_errors']:
try:
run(['docker', 'inspect', name], 'recover-owned-container', check=False, tolerate_logging=True)
except Exception as exc:
fail('Failed-create ownership recovery: ' + type(exc).__name__ + ': ' + str(exc))
if cid and identity and not status['ownership_errors']:
try:
info = inspect('final-container-inspect', tolerate_logging=True)
status['final_container_state'] = info.get('State', {})
if info.get('State', {}).get('OOMKilled'):
fail('Container OOMKilled')
except Exception as exc:
fail('Owned container cleanup inspection: ' + type(exc).__name__ + ': ' + str(exc))
if owner_confirmed and not status['ownership_errors']:
# Independent cleanup steps: receipt failure never skips stop or
# remove after fresh ownership proof has been saved in memory.
if setup_started:
for command in reversed(contract['commands']):
if command.get('evaluation_teardown_command'):
try:
execute(command['evaluation_teardown_command'], command['repository'] + '-teardown',
command['container_path'], environments[command['repository']], tolerate_logging=True)
except Exception as exc:
fail('Teardown: ' + type(exc).__name__ + ': ' + str(exc))
steps = [(['docker', 'cp', cid + ':/artifacts', str(cell / 'native-artifacts-final')], 'final-native-artifacts', 180),
(['docker', 'stop', '--time', '1', cid], 'stop', 30),
(['docker', 'rm', cid], 'remove', 30),
(['docker', 'inspect', cid], 'removed-container-inspect', 180)]
status['cleanup'].update(attempted=True, container_id=cid)
for argv, label, timeout in steps:
try:
result = run(argv, label, check=False, timeout=timeout, tolerate_logging=True)
if label != 'removed-container-inspect' and (result['returncode'] or result.get('timed_out')):
fail(label + ': ' + ('timeout' if result.get('timed_out') else 'exit ' + str(result['returncode'])))
except Exception as exc:
fail(label + ': ' + type(exc).__name__ + ': ' + str(exc))
removed = memory.get('remove', {}).get('record', {})
absent = memory.get('removed-container-inspect', {}).get('record', {})
missing_message = memory.get('removed-container-inspect', {}).get('stderr', b'').decode(errors='replace')
status['cleanup']['removed'] = (removed.get('returncode') == 0 and not removed.get('timed_out') and
absent.get('returncode') == 1 and not absent.get('timed_out') and
re.search(r'No such (?:object|container)', missing_message, re.I) is not None)
if not status['cleanup']['removed']:
fail('Owned container cleanup was not verified')
if status['ownership_errors']:
fail('Sticky ownership errors prohibit cleanup of a foreign/unverified container')
if status['issues']:
status['state'] = 'EVALUATION_ERROR'; status['resolved'] = False; status['complete_case_inventory'] = False
status['ended_utc'] = datetime.datetime.now(datetime.timezone.utc).isoformat()
status['receipt_persisted'] = True
if not persist_status('final', strict=False):
status['receipt_persisted'] = False
return status
def main(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--bench-root', type=Path, required=True, help='Portable Bench checkout with instances/ and published environments/')
parser.add_argument('--support-dir', type=Path, default=DEFAULT_SUPPORT, help='Pinned batch06 publication runner and reusable_support/')
parser.add_argument('--instance-id', required=True, choices=sorted(PROFILES))
parser.add_argument('--candidate-patches', type=Path, required=True, help='JSON repository-key to patch-path object; omitted key leaves its base unchanged')
parser.add_argument('--output-dir', type=Path, required=True)
parser.add_argument('--evaluator-resource-dir', type=Path)
parser.add_argument('--check-only', action='store_true')
args = parser.parse_args(argv)
try:
prepared = prepare_inputs(args.bench_root, args.instance_id, args.candidate_patches, args.output_dir,
args.support_dir, args.evaluator_resource_dir)
if args.check_only:
print(json.dumps({'instance_id': args.instance_id, 'state': 'INPUTS_VERIFIED', 'world': 'candidate',
'image': prepared['image']['image_ref'], 'patches': prepared['patches'],
'evaluator_resources': prepared['resource'], 'model_calls': 0, 'score_writes': 0,
'runtime_validation': 'NOT_RUN'}))
return 0
status = evaluate(prepared)
print(json.dumps({'instance_id': args.instance_id, 'state': status['state'], 'resolved': status.get('resolved', False),
'receipt': str(prepared['out'] / 'status.json'), 'receipt_persisted': status.get('receipt_persisted', False),
'issues': status['issues'], 'logging_errors': status['logging_errors']}))
return 2 if status['state'] == 'EVALUATION_ERROR' else 0
except (ValueError, OSError, KeyError, TypeError) as exc:
print(type(exc).__name__ + ': ' + str(exc), file=sys.stderr)
return 2
if __name__ == '__main__':
raise SystemExit(main())
|