| cast_to_float |
Ran ran, honoured the contract we drafted |
McGill-NLP/weblinx/weblinx/processing/outputs.py code served (permissive licence) · get_code("fa80bfc9b9704f8c") 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 float, 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
def cast_to_float(value):
"""
Checks if a value is an int or a float.
"""
if value is None:
return None
if isinstance(value, str):
value = value.strip()
try:
return float(value)
except ValueError:
return None
ARGS = {
"value": 42.5
}
- 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 float, 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
|
| compose_formatters |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/utils/format.py code served (permissive licence) · get_code("1ec7b369dd522796") 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 function. 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
# Define a minimal Turn class that the formatters will receive
class Turn:
def __init__(self):
self.text = "Hello world"
self.id = 1
self.metadata = {"key": "value"}
# Define some simple formatter functions that take a Turn and return a dict
def formatter_1(turn: 'Turn') -> dict:
return {"text": turn.text, "processed": True}
def formatter_2(turn: 'Turn') -> dict:
return {"id": turn.id, "length": len(turn.text)}
def formatter_3(turn: 'Turn') -> dict:
return {"metadata": turn.metadata, "timestamp": 12345}
# Create the arguments
ARGS = {
"formatters": [formatter_1, formatter_2, formatter_3]
}
- 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 function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
|
| filter_bboxes |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/utils/html.py code served (permissive licence) · get_code("4fcb1951b117a6e6") 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.
# Setup code to construct valid arguments for filter_bboxes
ARGS = {
"bboxes": {
"widget_1": {
"x": 10,
"y": 20,
"width": 50,
"height": 60
},
"widget_2": {
"x": 100,
"y": 150,
"width": 5,
"height": 5
},
"widget_3": {
"x": 200,
"y": 300,
"width": 30,
"height": 8
},
"widget_4": {
"x": 0,
"y": 0,
"width": -10,
"height": 20
}
},
"min_height": 10,
"min_width": 10,
"viewport_height": 500,
"viewport_width": 400
}
- 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
|
| format_action_arg_value |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/processing/outputs.py code served (permissive licence) · get_code("bc51f017163fe65f") 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
# The function takes a single parameter: arg_value
# It expects a string and performs string operations on it
# Let's test with various string inputs that exercise different code paths
# Test case 1: quoted string
arg_value_1 = '"hello"'
# Test case 2: float string
arg_value_2 = '3.14'
# Test case 3: positive integer string
arg_value_3 = '42'
# Test case 4: negative integer string
arg_value_4 = '-99'
# Test case 5: plain string with whitespace
arg_value_5 = ' plain_text '
ARGS = {
'arg_value': '"hello"'
}
- 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
|
| format_arg_item |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/utils/format.py code served (permissive licence) · get_code("4d03c832e78532b4") 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 torch
import numpy as np
class Turn:
def __init__(self, args):
self.args = args
# Create a minimal Turn object with args dictionary
turn = Turn({
'value': ' some example text that might be long ',
'text': 'Hello world',
'other_arg': 'test'
})
# Define ARGS dictionary with all parameters for format_arg_item
ARGS = {
'turn': turn,
'name': 'value',
'strip': True,
'max_length': 40,
'return_as': 'dict'
}
- 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 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
|
| format_prev_turns |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/processing/prompt.py code served (permissive licence) · get_code("a899f2c938e9474d") 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.
class Turn:
def __init__(self, index, intent):
self.index = index
self.intent = intent
class Replay:
def __init__(self, turns):
self.turns = turns
def __getitem__(self, key):
if isinstance(key, slice):
return [self.turns[i] for i in range(*key.indices(len(self.turns)))]
return self.turns[key]
def format_intent_func(turn, return_as=str):
if return_as == str:
return f"Turn {turn.index}: {turn.intent}"
else:
return {"turn_index": turn.index, "intent": turn.intent}
# Create sample turns
turns = [
Turn(0, "action_0"),
Turn(1, "action_1"),
Turn(2, "action_2"),
Turn(3, "action_3"),
Turn(4, "action_4"),
Turn(5, "action_5"),
Turn(6, "action_6"),
]
# Create replay object
replay = Replay(turns)
# Current turn to get previous turns for
current_turn = Turn(4, "current_action")
ARGS = {
"replay": replay,
"turn": current_turn,
"format_intent": format_intent_func,
"turn_sep": " ; ",
"num_prev_turns": 5,
"return_as": str,
}
- 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
|
| get_bracket_length |
Ran ran, honoured the contract we drafted |
McGill-NLP/weblinx/weblinx/processing/truncation.py code served (permissive licence) · get_code("c6518874884b35e2") 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
from transformers import AutoTokenizer
# Create a minimal stand-in tokenizer class that implements the required interface
class StandInTokenizer:
def __init__(self):
pass
def tokenize(self, text, add_special_tokens=False):
# Simple tokenization: split by spaces and special characters
# Return a list of tokens with length proportional to input
if not text:
return []
# Simple mock: return list of characters as tokens
return list(text)
# Use a real tokenizer from transformers for more realistic behavior
try:
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
except Exception:
# Fallback to stand-in if download fails
tokenizer = StandInTokenizer()
ARGS = {
"elem_open_bracket": "<",
"elem_close_bracket": ">",
"tokenizer": tokenizer,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, transformers — 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
|
| get_descendants |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/processing/dom.py code served (permissive licence) · get_code("44d3924c80fe3091") 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
import numpy as np
# Create a simple tree-like structure using a stand-in class
class TreeNode:
def __init__(self, value, children=None):
self.value = value
self.children = children if children is not None else []
def __iter__(self):
# This makes the node iterable, returning its children
return iter(self.children)
# Build a small tree structure
leaf1 = TreeNode("leaf1", [])
leaf2 = TreeNode("leaf2", [])
leaf3 = TreeNode("leaf3", [])
internal_node1 = TreeNode("internal1", [leaf1, leaf2])
internal_node2 = TreeNode("internal2", [leaf3])
root = TreeNode("root", [internal_node1, internal_node2])
ARGS = {
"node": root,
"max_depth": 2,
"current_depth": 0
}
- 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 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
|
| get_env_dict |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/utils/envs.py code served (permissive licence) · get_code("abbcbd290c538f35") 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 tempfile
from pathlib import Path
# Create a temporary .env file with some environment variables
with tempfile.NamedTemporaryFile(mode='w', suffix='.env', delete=False) as f:
f.write("API_KEY=secret123\n")
f.write("DATABASE_URL=postgres://localhost\n")
f.write("DEBUG=true\n")
temp_env_path = f.name
ARGS = {
'filepath': temp_env_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 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
|
| get_list_from_records_by_key |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/utils/recs.py code served (permissive licence) · get_code("b070440172fb7a66") 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
torch.manual_seed(0)
# The function expects:
# - records: dict (note: docstring says "list of dictionaries" but signature says dict)
# Looking at the function body: [r[key] for r in records]
# This iterates over records, so records must be iterable
# Each r must support indexing with r[key]
# So records should be a list of dicts, not a dict itself
# - key: str to extract from each record
# Create sample records as a list of dictionaries
records = [
{"name": "Alice", "age": 30, "score": 95},
{"name": "Bob", "age": 25, "score": 87},
{"name": "Charlie", "age": 35, "score": 92},
]
key = "name"
ARGS = {
"records": records,
"key": key,
}
- 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
|
| get_speaker |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/processing/prompt.py code served (permissive licence) · get_code("576db6c2c80cba48") 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 torch.nn as nn
torch.manual_seed(0)
ARGS = {
'utterance': 'say something speaker="instructor" to the user',
'instructor_name': 'User',
'navigator_name': 'Assistant',
'default_name': None
}
- 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_truncation_offsets |
Ran ran, honoured the contract we drafted |
McGill-NLP/weblinx/weblinx/processing/truncation.py code served (permissive licence) · get_code("e8d383f64048fb06") 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, ndim 1, dtype family int; 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
import numpy as np
torch.manual_seed(0)
# Construct a tokens dict with "input_ids" and "offset_mapping"
# offset_mapping is a list/array where each element is a tuple (start, end) of character offsets
tokens = {
"input_ids": torch.tensor([[101, 2054, 2003, 102]]), # dummy token IDs
"offset_mapping": [
(0, 0), # [CLS] token
(1, 5), # word 1
(6, 10), # word 2
(11, 15), # word 3
(15, 16), # [SEP] token
(16, 20), # word 4
(21, 25), # word 5
(26, 30), # word 6
]
}
length = 8
num_tokens_to_remove = 2
ARGS = {
"tokens": tokens,
"length": length,
"num_tokens_to_remove": num_tokens_to_remove,
}
- 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 tuple, ndim 1, dtype family int — 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
|
| group_record_to_dict |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/utils/recs.py code served (permissive licence) · get_code("176890ae96f63695") 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.
from copy import deepcopy
from collections import defaultdict
from typing import Any, List, Dict
# Construct records - a list of dictionaries with common keys
records = [
{
"category": "A",
"type": 1,
"value": 100,
"name": "record1"
},
{
"category": "A",
"type": 1,
"value": 200,
"name": "record2"
},
{
"category": "B",
"type": 2,
"value": 300,
"name": "record3"
},
{
"category": "B",
"type": 2,
"value": 400,
"name": "record4"
},
]
# Keys to group by
keys = ["category", "type"]
# Boolean flags
remove_keys = False
copy_flag = True
ARGS = {
"records": records,
"keys": keys,
"remove_keys": remove_keys,
"copy": copy_flag
}
- 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
|
| has_elem_in_viewport |
Ran ran, violated the contract we drafted |
McGill-NLP/weblinx/weblinx/utils/html.py code served (permissive licence) · get_code("1fec2e813060a926") 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.
# Stand-in class for webtasks.Turn
class Turn:
def __init__(self, index, bboxes, viewport_width, viewport_height):
self.index = index
self.bboxes = bboxes
self.viewport_width = viewport_width
self.viewport_height = viewport_height
# Create a turn with some bboxes
turn = Turn(
index=0,
bboxes={
"1234": {"x": 10, "y": 20, "width": 100, "height": 50},
"5678": {"x": 200, "y": 300, "width": 5, "height": 10},
},
viewport_width=800,
viewport_height=600
)
# Create element attributes dictionary
attrib_dict = {
"data-webtasks-id": "1234",
"class": "foo bar",
"id": "my-element"
}
ARGS = {
"turn": turn,
"attrib_dict": attrib_dict,
"key": "data-webtasks-id",
"min_height": 2,
"min_width": 2,
"verbose": False
}
- 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
|
| identity |
Ran ran, honoured the contract we drafted |
McGill-NLP/weblinx/weblinx/processing/prompt.py code served (permissive licence) · get_code("6b063e5a47833dd4") 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 Tensor, ndim 2, dtype family float, shape (2, 4) 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
torch.manual_seed(0)
ARGS = {
"x": torch.randn(2, 4)
}
- 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 Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) 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
|
| is_list_monotonically_increasing |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
McGill-NLP/weblinx/weblinx/utils/recs.py code served (permissive licence) · get_code("3ae8877f0adf8db3") 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
torch.manual_seed(0)
# Test case 1: monotonically increasing list
lst_increasing = [1, 2, 3, 4, 5]
ARGS = {
"lst": lst_increasing
}
- 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 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
|
| list_all_non_alphanum_chars |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/processing/outputs.py code served (permissive licence) · get_code("dcda9d27514120e0") 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
import numpy as np
# Construct arguments for list_all_non_alphanum_chars
ARGS = {
"other_chars_allowed": ['!', '@', '#', '$']
}
- 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 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
|
| open_html_with_encodings |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/utils/html.py code served (permissive licence) · get_code("63c7e3d03045c0db") 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 HTML file with valid UTF-8 encoding
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "test.html")
html_content = """<!DOCTYPE html>
<html>
<head>
<title>Test Page</title>
</head>
<body>
<h1>Hello World</h1>
<p>This is a test HTML file.</p>
</body>
</html>"""
with open(temp_file, 'w', encoding='utf-8') as f:
f.write(html_content)
ARGS = {
'path': temp_file,
'encodings': ['utf-8', 'latin-1'],
'raise_error': True
}
- 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
|
| remap_bboxes |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/webllama/examples/browsergym/agent.py code served (permissive licence) · get_code("84bd76bf303ce78b") 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 torch
import numpy as np
torch.manual_seed(0)
# The function remap_bboxes takes:
# 1. bboxes: a dictionary where keys are old ids and values are bbox data
# 2. attrs_map: a dictionary mapping old ids to new ids
# Create a simple bboxes dictionary with old ids as keys
bboxes = {
0: torch.tensor([10.0, 20.0, 30.0, 40.0]),
1: torch.tensor([50.0, 60.0, 70.0, 80.0]),
2: torch.tensor([15.0, 25.0, 35.0, 45.0])
}
# Create attrs_map that maps old ids to new ids
attrs_map = {
0: 'cat',
1: 'dog',
2: 'bird'
}
ARGS = {
'bboxes': bboxes,
'attrs_map': attrs_map
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy, torch — 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
|
| remove_latex |
Ran ran, violated the contract we drafted |
McGill-NLP/webllama/app/Results.py code served (permissive licence) · get_code("d31d4a5938635d95") 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 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)
# Analyze the function:
# - Takes parameter 'x'
# - Checks if x is a tuple, str, or other type
# - If tuple, recursively applies remove_latex to each element
# - If str, performs string operations (startswith, partition, rpartition)
# - Otherwise returns x unchanged
# Test cases for the function:
test_cases = [
# Simple string with LaTeX
"prefix{content}suffix",
# String without braces
"simple_string",
# String starting with 'Unnamed'
"Unnamed: something",
# Tuple of strings
("string1{latex}end", "Unnamed: test", "no_braces"),
# Non-string type
42,
# Nested tuple
(("inner{content}outer", "Unnamed"), "simple"),
# Empty string
"",
# String with multiple braces
"start{first}middle{second}end",
]
# The function parameter is 'x', which can be:
# - a string (with or without LaTeX)
# - a tuple (containing strings or other tuples)
# - any other type
ARGS = {
"x": "example{LaTeX}text"
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| shorten |
Ran ran; our contract draft was wrong, not the code |
McGill-NLP/weblinx/weblinx/utils/format.py code served (permissive licence) · get_code("d20962095e5b96d0") 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
ARGS = {
"text": "The quick brown fox jumps over the lazy dog. This is a longer text that will be truncated.",
"max_length": 20
}
- 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
|
| build_cond_df |
Not yet run unverified (harvested, no recorded run) |
McGill-NLP/webllama/app/Results.py code served (permissive licence) · get_code("168f0e5f647cc7c9") How it ran |
| get_tree_repr_simple |
Not yet run unverified (harvested, no recorded run) |
McGill-NLP/weblinx/weblinx/processing/dom.py code served (permissive licence) · get_code("af79280883191a10") How it ran |
| load_and_clean_df |
Not yet run unverified (harvested, no recorded run) |
McGill-NLP/webllama/app/Results.py code served (permissive licence) · get_code("78b8c5d1e64ad4a3") How it ran |
| prune_tree |
Not yet run unverified (harvested, no recorded run) |
McGill-NLP/weblinx/weblinx/processing/dom.py code served (permissive licence) · get_code("7c1d79a2be5ce989") How it ran |
| reduce_list_of_lengths |
Not yet run unverified (harvested, no recorded run) |
McGill-NLP/weblinx/weblinx/processing/truncation.py code served (permissive licence) · get_code("0ac8898c0f3f43ec") How it ran |
| resolve_cache_path |
Not yet run unverified (harvested, no recorded run) |
McGill-NLP/weblinx/weblinx/utils/hydra.py code served (permissive licence) · get_code("736f8a0adf254065") How it ran |