| build_prompt_standard |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/utils.py code served (permissive licence) · get_code("cde900d8d85bd592") 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
from typing import Dict, Optional
# Define the descriptions dict that is used in the function
descriptions = {
'racebet': "The objective of this game is guessing which camel is going to win the race. Betting is performed by placing the player in one of the corresponding betting spots. No points are given in this game. You either bet for the one that wins (and the player wins) or you don't (and the player loses).",
'digdug': 'The player must collect all gems and gold coins in the cave, digging its way through it, to win the game. There are also enemies in the level that kill the player on collision with them. Also, the player can shoot boulders by pressing USE two consecutive time steps, which kill enemies.',
'brainman': 'The player must push keys into doors to open them, to reach the exit to win the game. Many gems around are available for collection, which give score to the player. Keys are pushed by colliding with them, and they are propelled in a straight line until finding a sprite to collide against, when they stop. If they hit a door, both the door and the key are destroyed.',
'defender': 'The objective of this game is to avoid that the enemies destroy your city. The enemies are spawned at the right of the screen and cross it while bombing the city. The player must eliminate these enemies as soon as possible so the city is not destroyed, otherwise the player loses. The player\'s ammunition is supplied from the top of the screen and must be collected periodically to avoid running out of ammo.',
'lasers2': 'The objective of this game is to reach the exit, which is typically blocked by a mud sprite. The mud can be destroyed by directing a laser to it. There are several laser cannons whose orientation can be changed by the player shooting at them. Apart from this, there are several crystal blocks, which can also be rotated, that deflect the lasers in a certain direction. Lasers kill the player when in contact.',
'boulderchase': 'In this game, the player must dig inside a cave to collect at least 9 gems and reach the exit. As the player digs, boulders that are left without a ground fall and can kill the player upon collision. Enemies also move around the cave, being able to dig as well. When digging, they drop gems that can also be collected by the player. Enemies are also killed by boulders and kill the player upon contact.',
'portals': 'The player controls an avatar that needs to find the exit of a maze. The maze is full of entry and exit portals, and every time the player goes through an entry portal they will be teleported to an exit portal at random. The maze is also full of enemies and missiles that kill the player on contact.',
'iceandfire': 'The objective of this game is to find the exit of the maze. The maze has multiple traps, two different types of surfaces (ice and fire), and two types of boots (for ice and fire) that can be collected. The special surfaces kill the player on contact, unless the appropriate boots are picked up beforehand. There are several coins scattered around the level that give the player some score.',
'cakybaky': 'The objective of the game is to bake a cake. There are several ingredients that must be collected in order, to follow the recipe. This order to follow is flour, milk, eggs, sugar, butter and cherries, although not all levels have all these ingredients. There are angry chefs around the level that chase the player, although they only care about their favourite ingredient, so only the ones that prefer the next ingredient to be picked up are active at each time. If a chef collides with the player, the player loses.'
}
AVAILABLE_GAMES = list(descriptions.keys())
def log_progress(message: str) -> None:
print(f'[TRACE] {message}', flush=True)
def build_prompt_standard(observation: str, description_map: Optional[Dict[str, str]]=None) -> str:
"""Construct the default classification prompt with all game descriptions."""
log_progress('build_prompt_standard: constructing classification prompt')
description_source = description_map if description_map is not None else descriptions
num_list = '\n'.join((f'{i}: {g}' for i, g in enumerate(AVAILABLE_GAMES)))
all_descriptions = 'Here are the descriptions of all the available games, the observations later are from gameplay of one of these games:\n\n'
for g in AVAILABLE_GAMES:
desc = description_source.get(g, 'No description available.')
all_descriptions += f'{g}:\n{desc}\n'
all_descriptions += 'End of game description\n' + '-' * 40 + '\n'
return 'You are given 10 consecutive ASCII-rendered game screens produced by random actions in a single game. From their style, symbols, layout, and recurring patterns, deduce which game they come from. Choose exactly one title from the list below.\n\nAvailable games:\n' + num_list + '\n\n' + all_descriptions + 'Answer format (strict):\n{ONLY the selected game name}.\nASCII observations (10 frames):\n```text\n' + observation + '\n```'
# Create sample observation with 10 ASCII frames
sample_observation = "\n".join([
"Frame 1:",
"###########",
"#@ . #. #",
"# ## ## # #",
"# # # # #",
"###########",
"",
"Frame 2:",
"###########",
"# @ . #.#",
"# ## ## # #",
"# # # # #",
"###########",
] * 5)[:500] # Truncate to reasonable size
# Build ARGS dict with all parameters
ARGS = {
'observation': sample_observation,
'description_map': None
}
- 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
|
| build_prompt_vgdl |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/utils.py code served (permissive licence) · get_code("848ca2aa57d2f89a") 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 torch
def log_progress(message: str) -> None:
print(f'[TRACE] {message}', flush=True)
def build_prompt_vgdl(observation: str):
"""Return a VGDL-authoring chat prompt for VGDL generation jobs."""
log_progress('build_prompt_vgdl: preparing VGDL prompt')
system = 'You are an expert in Video Game Description Language (VGDL). Given a short description and a sequence of 10 gameplay observations with actions, infer the minimal VGDL specification.'
return [{'role': 'system', 'content': system}, {'role': 'user', 'content': observation}]
ARGS = {
'observation': 'A simple platformer game where the player controls a character that can move left and right, jump to avoid obstacles, and collect coins. Gravity applies downward.'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — 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
|
| clean_and_extract |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/overall_vgdl_results_analysis.py code served (permissive licence) · get_code("025c14a9021940af") 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 tuple. 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 tempfile
import re
# Create a temporary file with sample content that matches the expected format
temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='_new_paper_stats.txt', delete=False, encoding='utf-8')
sample_content = """
1. PERFORMANCE METRICS
Overall LLM Win Rates:
| Judge Model | Win Rate | Draw Rate | Loss Rate | Count |
|---|---|---|---|---|
| GPT-4 | 45.50% | 30.25% | 24.25% | 200 |
| Claude | 48.75% | 28.50% | 22.75% | 200 |
2. ANALYSIS
Quantitative Metrics per Level:
| Level | Metric1 | Metric2 | Metric3 | Metric4 |
|---|---|---|---|---|
| Easy | 0.85 | 0.92 | 0.78 | 0.88 |
| Hard | 0.72 | 0.81 | 0.65 | 0.75 |
Aggregated LLM Preference per Level:
| Level | Win Rate | Draw Rate | Loss Rate | Count |
|---|---|---|---|---|
| Easy | 52.00% | 25.00% | 23.00% | 100 |
| Hard | 48.50% | 32.00% | 19.50% | 100 |
Quantitative Metrics per Game:
| Game | Metric1 | Metric2 | Metric3 | Metric4 |
|---|---|---|---|---|
| Chess | 0.91 | 0.87 | 0.89 | 0.85 |
| Checkers | 0.78 | 0.82 | 0.76 | 0.80 |
Aggregated LLM Preference per Game:
| Game | Win Rate | Draw Rate | Loss Rate | Count |
|---|---|---|---|---|
| Chess | 55.00% | 20.00% | 25.00% | 100 |
| Checkers | 46.00% | 37.00% | 17.00% | 100 |
3. ANALYSIS
"""
temp_file.write(sample_content)
temp_file.close()
file_path = temp_file.name
ARGS = {
'file_path': file_path
}
- 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 tuple — a tuple output has no array shape of its own; none is 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
|
| compare |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/GVGAI_GYM/gym_gvgai/envs/gvgai/check_build.py code served (permissive licence) · get_code("606ee3293f860d2f") 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 torch
import numpy as np
torch.manual_seed(0)
# The function compare(hash1, hash2) converts both arguments to frozensets
# and checks equality. So hash1 and hash2 should be hashable iterables
# (lists, tuples, sets, etc.) that can be converted to frozensets.
# Create two different hashable iterables
hash1 = [1, 2, 3, 4]
hash2 = [4, 3, 2, 1]
ARGS = {
"hash1": hash1,
"hash2": hash2,
}
- 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 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
|
| convert_runtime_to_seconds |
Ran ran, honoured the contract we drafted |
jiwatode-mohit/SCM_4_GVGAI/overall_game_pred_analysis.py code served (permissive licence) · get_code("97acd8de600ab21b") 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 int, ndim 0, dtype family int, 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
# Test case 1: None input
runtime_str_1 = None
# Test case 2: Simple time format (HH:MM:SS)
runtime_str_2 = "01:30:45"
# Test case 3: Time format with days (D-HH:MM:SS)
runtime_str_3 = "5-02:15:30"
# Test case 4: Zero values
runtime_str_4 = "00:00:00"
# Test case 5: With days and zeros
runtime_str_5 = "2-00:00:00"
ARGS = {
"runtime_str": runtime_str_2
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, 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
|
| dirHash |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/GVGAI_GYM/gym_gvgai/envs/gvgai/check_build.py code served (permissive licence) · get_code("a2ce8f3431500582") 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 os
import tempfile
import shutil
# Create a temporary directory with some .java files for testing
temp_dir = tempfile.mkdtemp()
# Create some subdirectories and .java files
os.makedirs(os.path.join(temp_dir, "src"), exist_ok=True)
os.makedirs(os.path.join(temp_dir, "src", "subdir"), exist_ok=True)
# Write test .java files
with open(os.path.join(temp_dir, "src", "Test1.java"), "w") as f:
f.write("public class Test1 { }")
with open(os.path.join(temp_dir, "src", "subdir", "Test2.java"), "w") as f:
f.write("public class Test2 { }")
# Also write a non-.java file that should be ignored
with open(os.path.join(temp_dir, "src", "readme.txt"), "w") as f:
f.write("This should be ignored")
ARGS = {
"dirpath": temp_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 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
|
| ensure_unique_json_path |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/vgdl_gen.py code served (permissive licence) · get_code("72283c31cce711e8") 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.
import datetime as dt
from pathlib import Path
import tempfile
import os
# Create a temporary directory for testing
temp_dir = tempfile.mkdtemp()
# Test case 1: Non-existent path
non_existent_path = Path(temp_dir) / "output.json"
# Test case 2: Existing path (create it first)
existing_path = Path(temp_dir) / "existing.json"
existing_path.touch()
# Use the non-existent path as the main test argument
ARGS = {
"path": non_existent_path
}
- 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
|
| fileHash |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/GVGAI_GYM/gym_gvgai/envs/gvgai/check_build.py code served (permissive licence) · get_code("5ab6d28b05916db8") 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
import os
# Create a temporary file with some content for testing
temp_dir = tempfile.mkdtemp()
test_file = os.path.join(temp_dir, "test.txt")
with open(test_file, 'wb') as f:
f.write(b"Hello, this is test content for hashing.")
ARGS = {
'filepath': test_file,
'blocksize': 4096
}
- 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
|
| generate_latex |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/overall_vgdl_results_analysis.py code served (permissive licence) · get_code("7137ea4bf391d60d") 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
torch.manual_seed(0)
ARGS = {
'title': 'Model Performance Results',
'headers': ['Metric', 'Value', 'Status'],
'rows': [
['Accuracy', '95.5%', 'Good'],
['Loss', '0.045', 'Acceptable'],
['F1-Score', '0.92_test', 'Excellent']
]
}
- 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
|
| get_src |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/GVGAI_GYM/build.py code served (permissive licence) · get_code("b9479826c3f56102") 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 os
import tempfile
import shutil
# Create a temporary directory structure with .java files
temp_dir = tempfile.mkdtemp()
os.makedirs(os.path.join(temp_dir, "src", "main", "java"), exist_ok=True)
os.makedirs(os.path.join(temp_dir, "src", "test"), exist_ok=True)
# Create some .java files
with open(os.path.join(temp_dir, "src", "main", "java", "HelloWorld.java"), "w") as f:
f.write("public class HelloWorld {}")
with open(os.path.join(temp_dir, "src", "main", "java", "Utils.java"), "w") as f:
f.write("public class Utils {}")
with open(os.path.join(temp_dir, "src", "test", "TestMain.java"), "w") as f:
f.write("public class TestMain {}")
# Create some non-.java files that should be ignored
with open(os.path.join(temp_dir, "src", "main", "java", "config.xml"), "w") as f:
f.write("<config></config>")
with open(os.path.join(temp_dir, "README.md"), "w") as f:
f.write("# Project")
ARGS = {
"path": temp_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 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
|
| load_all_results |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/overall_game_pred_analysis.py code served (permissive licence) · get_code("f2b12fea0b317d6f") 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 DataFrame. 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 json
import tempfile
import shutil
# Create a temporary directory with test JSON files
temp_dir = tempfile.mkdtemp()
# Create sample JSON data matching the expected structure
sample_data_1 = {
"subsets": {
"subset_a": {
"mode_1": {
"0": {
"game_1": {"prediction": "correct_answer"},
"game_2": {"prediction": "wrong_answer"}
}
}
}
}
}
sample_data_2 = {
"subsets": {
"subset_b": {
"mode_2": {
"0": {
"game_3": {"prediction": "correct_answer"},
"game_4": {"prediction": "another_answer"}
},
"1": {
"game_5": {"prediction": "test"}
}
}
}
}
}
# Write test JSON files
with open(os.path.join(temp_dir, "model_v1@4bit-nf4.json"), "w") as f:
json.dump(sample_data_1, f)
with open(os.path.join(temp_dir, "model_v2@8bit.json"), "w") as f:
json.dump(sample_data_2, f)
# Define ARGS with the temporary directory path
ARGS = {
"folder_path": temp_dir
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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
|
| parse_model_name |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/overall_game_pred_analysis.py code served (permissive licence) · get_code("7ac2e253ee8fbfb9") 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 os
def parse_model_name(filename):
"""
Extracts a distinct model identifier from the filename.
Treats quantized versions (e.g., 4bit-nf4) as separate models.
"""
base = os.path.basename(filename)
name_part = os.path.splitext(base)[0]
if '@' in name_part:
parts = name_part.split('@')
base_model = parts[0]
try:
if '__' in base_model:
base_model = base_model.split('__')[1]
except IndexError:
pass
suffix = parts[1]
quant_markers = ['4bit', '8bit', 'nf4', 'gguf', 'awq', 'gptq', 'int4', 'int8', 'q4', 'q8']
found_quants = [marker for marker in quant_markers if marker in suffix.lower()]
if found_quants:
quant_tag = suffix.replace('w_description', '').strip('_').strip('-')
if quant_tag:
return f'{base_model} ({quant_tag})'
return base_model
return name_part
ARGS = {
'filename': '/path/to/model_name@4bit-nf4.bin'
}
- 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
|
| strip_description_prefix |
Ran ran; our contract draft was wrong, not the code |
jiwatode-mohit/SCM_4_GVGAI/utils.py code served (permissive licence) · get_code("cc890a1286667b40") 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
def log_progress(message: str) -> None:
print(f'[TRACE] {message}', flush=True)
DESCRIPTION_SEPARATOR = 'End of game description\n----------------------------------------\n'
def strip_description_prefix(text: str) -> str:
"""Remove the prepended description section from cached observations."""
log_progress('strip_description_prefix: inspecting observation text')
if not text:
return text
if DESCRIPTION_SEPARATOR in text:
_, remainder = text.split(DESCRIPTION_SEPARATOR, 1)
return remainder.lstrip('\n')
return text
ARGS = {
'text': 'End of game description\n----------------------------------------\nThis is the remainder of the observation.'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- 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
|
| get_game_description |
Not yet run unverified (harvested, no recorded run) |
jiwatode-mohit/SCM_4_GVGAI/vgdl_gen.py code served (permissive licence) · get_code("252a4a7a15731a27") How it ran |
| read_ground_truth_vgdl |
Not yet run unverified (harvested, no recorded run) |
jiwatode-mohit/SCM_4_GVGAI/vgdl_gen.py code served (permissive licence) · get_code("e1ab6ecf3146b00c") How it ran |