| _extract_test_block_from_text |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("0d26355a0593d1cd") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import re
# Construct arguments for _extract_test_block_from_text
text = '''
/// This is a test header comment
test "my_test" {
let x = 10;
let y = 20;
}
test "another_test" {
let z = 30;
}
'''
test_name = "my_test"
ARGS = {
'text': text,
'test_name': test_name
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _find_test_file |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("3e52f0603142fd16") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned PosixPath. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
from pathlib import Path
import tempfile
import os
# Create a temporary directory structure for testing
temp_dir = tempfile.mkdtemp()
project_dir = Path(temp_dir)
# Create some subdirectories and files
package_dir = project_dir / "mypackage"
package_dir.mkdir(exist_ok=True)
# Create a test file in the package directory
test_file = package_dir / "test_module.py"
test_file.write_text("# test file")
# Create a test file in the root project directory
root_test_file = project_dir / "root_test.py"
root_test_file.write_text("# root test")
# Create a failure dict with filename and package
failure = {
'filename': 'test_module.py',
'package': 'mypackage'
}
ARGS = {
'project_dir': str(project_dir),
'failure': failure
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type PosixPath — a PosixPath output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PosixPath output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _format_failure_message |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("5523b61639d585a9") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
from pathlib import Path
import json
# Create a temporary directory and test file structure
temp_dir = tempfile.mkdtemp()
project_dir = Path(temp_dir)
# Create a test file with proper structure
test_file_path = project_dir / "test_example.txt"
test_content = '''/// This is a test header comment
test "my_test_case" {
some validation code
assert something
}
test "another_test" {
more code here
}
'''
test_file_path.write_text(test_content, encoding='utf-8')
# Create a package subdirectory with another test file
package_dir = project_dir / "mypackage"
package_dir.mkdir(exist_ok=True)
package_test_file = package_dir / "test_package.txt"
package_test_content = '''test "packaged_test" {
package test code
}
'''
package_test_file.write_text(package_test_content, encoding='utf-8')
# Create various failure dictionaries to test different code paths
failure_basic = {
'test_name': 'my_test_case',
'message': 'Test failed',
'kind': 'AssertionError',
'expected': 'True',
'actual': 'False',
'filename': 'test_example.txt',
'package': None
}
failure_with_dict_message = {
'test_name': 'packaged_test',
'message': {'error': 'validation failed', 'code': 42},
'kind': 'ValidationError',
'filename': 'test_package.txt',
'package': 'mypackage'
}
failure_minimal = {
'test_name': 'unknown_test',
'message': 'Something went wrong',
}
failure_empty = {}
# Build ARGS to test _format_failure_message with various inputs
ARGS = {
'failure': failure_basic,
'project_dir': str(project_dir)
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _is_selection_error |
Ran ran, violated the contract we drafted |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("5f4997aeaa42de77") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
ARGS = {
"message": "Error: not unique"
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _parse_failure_jsonl |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("b5f7c09f9a07afea") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import json
# The function _parse_failure_jsonl takes a single parameter: output
# which should be a string containing newline-separated JSON lines.
# Each line should be parseable as JSON and represent a dict with a 'test_name' key.
output = """{"test_name": "test_foo", "status": "failed", "error": "assertion error"}
{"test_name": "test_bar", "status": "passed"}
{"test_name": "test_baz", "error": "timeout"}
invalid json line
{"not_a_dict": "value"}
{"test_name": "test_qux"}
"""
ARGS = {
"output": output
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _parse_test_summary |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("2d84a21c452eeb6f") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import re
SUMMARY_RE = re.compile('Total tests:\\s*(\\d+),\\s*passed:\\s*(\\d+),\\s*failed:\\s*(\\d+)')
def _parse_test_summary(output):
match = SUMMARY_RE.search(output)
if not match:
return None
return {'total': int(match.group(1)), 'passed': int(match.group(2)), 'failed': int(match.group(3))}
# Test case 1: Valid output with test summary
output_valid = "Running tests...\nTotal tests: 42, passed: 38, failed: 4\nDone."
# Test case 2: Output without summary
output_invalid = "Running tests...\nNo summary found.\nDone."
ARGS = {
'output': output_valid
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| collect_labels |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI-Eval/claude-opus-4.5/cdcl/try.py code served (permissive licence) · get_code("48b9834c9dd08085") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import re
def collect_labels(text: str) -> list[str]:
labels: list[str] = []
for line in text.splitlines():
stripped = line.lstrip()
if stripped.startswith('//'):
continue
match = re.match('^\\s*test\\s+"([^"]+)"', line)
if match:
labels.append(match.group(1))
return labels
# Construct test input
test_text = """
// This is a comment
test "label1"
test "label2"
test "label3"
// another comment
test "label4"
some other line
"""
ARGS = {
"text": test_text
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| colorize |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI-Eval/claude-opus-4.5/cdcl/try.py code served (permissive licence) · get_code("bd08390f95c0fe75") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import sys
class Colors:
GREEN = '\x1b[92m'
RED = '\x1b[91m'
YELLOW = '\x1b[93m'
BLUE = '\x1b[94m'
RESET = '\x1b[0m'
BOLD = '\x1b[1m'
def supports_color() -> bool:
if not hasattr(sys.stdout, 'isatty'):
return False
if not sys.stdout.isatty():
return False
return True
USE_COLOR = supports_color()
def colorize(text: str, color: str) -> str:
if USE_COLOR:
return f'{color}{text}{Colors.RESET}'
return text
ARGS = {
'text': 'Hello, World!',
'color': Colors.GREEN
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| copy_project |
Ran ran, violated the contract we drafted |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("d47e662df259f5cf") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import shutil
import tempfile
from pathlib import Path
# Create temporary directories for testing
src_dir = tempfile.mkdtemp(prefix='src_')
dst_dir = tempfile.mkdtemp(prefix='dst_')
# Set up source directory with some test files
src_path = Path(src_dir)
(src_path / 'file1.txt').write_text('content1')
(src_path / 'subdir').mkdir(exist_ok=True)
(src_path / 'subdir' / 'file2.txt').write_text('content2')
# Set up destination directory with some files (including ones to be cleaned)
dst_path = Path(dst_dir)
(dst_path / 'old_file.txt').write_text('old_content')
(dst_path / 'old_subdir').mkdir(exist_ok=True)
(dst_path / 'old_subdir' / 'old_file2.txt').write_text('old_content2')
# Create a _priv_test directory that should be preserved
priv_test_dir = dst_path / 'data_priv_test'
priv_test_dir.mkdir(exist_ok=True)
(priv_test_dir / 'priv_test.mbt').write_text('private_data')
ARGS = {
'src_dir': src_dir,
'dst_dir': dst_dir,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| generate_moonbit |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI-Eval/deepseek-v3.2/hpack/parse_huffman.py code served (permissive licence) · get_code("7a0a58d0e71fa07f") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
# Analyze the function: it takes 'entries' which is iterated over
# Each entry is either None or a tuple of (bits, hexcode, length)
# bits is a string representation of bits
# hexcode is a hex string
# length is an integer
# Build sample entries for Huffman table
# RFC 7541 Huffman codes have symbols 0-255 plus EOS symbol 256
# Each entry should be (bits_string, hex_string, length_int)
entries = [
('00000', '0', 5), # symbol 0
('00001', '1', 5), # symbol 1
('00010', '2', 5), # symbol 2
None, # symbol 3 - missing
('00011', '3', 5), # symbol 4
('00100', '4', 5), # symbol 5
('00101', '5', 5), # symbol 6
('00110', '6', 5), # symbol 7
('00111', '7', 5), # symbol 8
('01000', '8', 5), # symbol 9
('01001', '9', 5), # symbol 10
('01010', 'a', 5), # symbol 11
('01011', 'b', 5), # symbol 12
None, # symbol 13 - missing
('01100', 'c', 5), # symbol 14
('01101', 'd', 5), # symbol 15
('01110', 'e', 5), # symbol 16
('01111', 'f', 5), # symbol 17
('10000', '10', 6), # symbol 18
('10001', '11', 6), # symbol 19
('10010', '12', 6), # symbol 20
]
ARGS = {
'entries': entries
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| run_cdcl_test_streaming |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("e49ed3ddb63cda58") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import sys
import io
import threading
import tempfile
from unittest.mock import Mock, MagicMock
# Create a mock wfile object that behaves like an HTTP response file
wfile = io.BytesIO()
# Create a temporary project directory
project_dir = tempfile.mkdtemp()
# Basic parameters
timeout = 10800
per_test_timeout = 10
keepalive_interval = 15
test_name = "test_example"
test_file = "test_file.py"
request_id = "req_12345"
# Create a threading.Event for the cancelled flag
cancelled = threading.Event()
cancelled.clear() # Not cancelled
# Construct the ARGS dictionary
ARGS = {
'wfile': wfile,
'project_dir': project_dir,
'timeout': timeout,
'per_test_timeout': per_test_timeout,
'keepalive_interval': keepalive_interval,
'test_name': test_name,
'test_file': test_file,
'request_id': request_id,
'cancelled': cancelled
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| run_moon_build |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("db5f1c7ce134271e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import subprocess
import signal
import threading
from datetime import datetime
from unittest.mock import MagicMock
import tempfile
# Create a temporary directory to use as project_dir
temp_dir = tempfile.mkdtemp()
# Create a mock cancelled event
cancelled_event = threading.Event()
# Define ARGS dict with all parameters for run_moon_build
ARGS = {
'project_dir': temp_dir,
'timeout': 120,
'request_id': 'test_request_123',
'cancelled': cancelled_event
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| send_sse_comment |
Ran ran, violated the contract we drafted |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("bdd2704909cc54c3") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import io
# Create a mock file-like object that supports write() and flush()
class MockWFile:
def __init__(self):
self.buffer = io.BytesIO()
def write(self, data):
self.buffer.write(data)
def flush(self):
pass
wfile = MockWFile()
comment = "keep-alive"
ARGS = {
"wfile": wfile,
"comment": comment,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| send_sse_event |
Ran ran, violated the contract we drafted |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("c39d6db42bcfe568") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import json
import io
# Create a mock file-like object that supports write() and flush()
class MockWFile:
def __init__(self):
self.buffer = io.BytesIO()
def write(self, data):
self.buffer.write(data)
def flush(self):
pass
# Construct valid arguments
wfile = MockWFile()
event_type = "update"
data = {
"status": "processing",
"progress": 42,
"message": "Task in progress",
"nested": {"key": "value"}
}
ARGS = {
"wfile": wfile,
"event_type": event_type,
"data": data
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| status_symbol |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI-Eval/claude-opus-4.5/cdcl/try.py code served (permissive licence) · get_code("6fed0709f2c2de4c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import sys
class Colors:
GREEN = '\x1b[92m'
RED = '\x1b[91m'
YELLOW = '\x1b[93m'
BLUE = '\x1b[94m'
RESET = '\x1b[0m'
BOLD = '\x1b[1m'
def supports_color() -> bool:
if not hasattr(sys.stdout, 'isatty'):
return False
if not sys.stdout.isatty():
return False
return True
USE_COLOR = supports_color()
def colorize(text: str, color: str) -> str:
if USE_COLOR:
return f'{color}{text}{Colors.RESET}'
return text
def status_symbol(status: str) -> str:
if status == 'pass':
return colorize('PASS', Colors.GREEN)
if status == 'fail':
return colorize('FAIL', Colors.RED)
if status == 'timeout':
return colorize('TIMEOUT', Colors.YELLOW)
if status == 'oom':
return colorize('OOM', Colors.YELLOW)
return colorize(status.upper(), Colors.YELLOW)
ARGS = {
'status': 'pass'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| terminate_process_gracefully |
Ran ran; our contract draft was wrong, not the code |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("719368dd9fb84c7b") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import subprocess
import os
import signal
# Create a simple subprocess that we can terminate
# We'll create a process that sleeps for a long time
proc = subprocess.Popen(
['sleep', '100'],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
preexec_fn=os.setsid # Create a new process group so we can kill it
)
ARGS = {
'proc': proc,
'grace_period': 5
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| handle_proj_submit_streaming |
Not yet run unverified (harvested, no recorded run) |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("52c4ad71a7b7b591") How it ran |
| log |
Not yet run unverified (harvested, no recorded run) |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("6c8362c015ee20dd") How it ran |
| register_process |
Not yet run unverified (harvested, no recorded run) |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("786d0d4d4541702b") How it ran |
| run_moon_test |
Not yet run unverified (harvested, no recorded run) |
moonbitlang/SWE-AGI/docker/server.py code served (permissive licence) · get_code("f0c203f3c5165c98") How it ran |