| add_highlight_tokidx |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/show.py code served (permissive licence) · get_code("ee20d0700e2f61f7") 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 List
# Set seed for reproducibility
torch.manual_seed(0)
# Construct arguments for add_highlight_tokidx
src_tok = ['hello', 'world', 'this', 'is', 'a', 'test']
slne = [0, 2, 4]
color_name = 'GREEN'
ARGS = {
'src_tok': src_tok,
'slne': slne,
'color_name': color_name
}
- 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
|
| create_tokenizer |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/tokenizer.py code served (permissive licence) · get_code("a3254eef985754fe") 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 type. 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 logging
logging.basicConfig(level=logging.INFO)
ARGS = {
'lang': 'en',
'name': 'whitespace'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- MeCab, sacremoses, transformers — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type type — a type output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a type 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
|
| create_tokenizer4pairs |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/tokenizer.py code served (permissive licence) · get_code("3c2ffcbb4d795cb4") 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 logging
logging.basicConfig(level=logging.INFO)
# Setup for create_tokenizer4pairs
# This function takes src_lang, tgt_lang, and pretokname as parameters
# and calls create_tokenizer for each language
# Valid language/tokenizer combinations based on the function logic:
# - lang='ja' returns MecabTokenizer (but requires MeCab library)
# - name='mbertcased' returns MultilingBertCasedBasicTokenizer
# - name='whitespace' returns WhitespaceTokenizer
# - name='moses' returns MosesTokenizer (but requires sacremoses library)
# To avoid external dependencies, we'll use 'whitespace' which has no external deps
ARGS = {
'src_lang': 'en',
'tgt_lang': 'fr',
'pretokname': 'whitespace'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- MeCab, sacremoses, transformers — 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_sent_idx |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/xqb/display_explicitation.py code served (permissive licence) · get_code("d501e482699c498b") 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
import numpy as np
# Analyze the function:
# - sents_seg: iterable of tuples (s, e) representing sentence start and end indices
# - start_idx: an integer index to search for within the segments
# - The function iterates through sents_seg looking for a segment where s <= start_idx <= e
# Create valid test data
sents_seg = [
(0, 10), # sentence 0: indices 0-10
(11, 25), # sentence 1: indices 11-25
(26, 40), # sentence 2: indices 26-40
]
# start_idx should be within one of the ranges
start_idx = 15 # falls within sentence 1 (11-25)
ARGS = {
'sents_seg': sents_seg,
'start_idx': start_idx,
}
- 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 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_token_char_indices |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/utils.py code served (permissive licence) · get_code("9820556ecac3062a") 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 2, 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
# Define ARGS for the get_token_char_indices function
# The function takes:
# - sent: a string (a sentence)
# - toks: a list of tokens (strings)
sent = "I ate apple."
toks = ["I", "ate", "apple", "."]
ARGS = {
"sent": sent,
"toks": toks
}
- 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 2, dtype family int — 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_unaligned_idx |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/utils.py code served (permissive licence) · get_code("c1968e7cd9190083") 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 2, 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.
# Analyze the function to understand what it needs
# get_unaligned_idx takes:
# 1. align_words: List[tuple] - list of (i, j) pairs representing word alignments
# 2. src_tok: List[str] - source tokens (list of strings)
# 3. tgt_tok: List[str] - target tokens (list of strings)
#
# The function finds which token indices are NOT aligned between source and target.
# It iterates through align_words tuples, builds sets of aligned indices,
# then returns unaligned indices.
# Create test data
align_words = [(0, 0), (1, 1), (2, 2)] # Source indices 0,1,2 aligned with target 0,1,2
src_tok = ["hello", "world", "there", "friend"] # 4 source tokens (indices 0-3)
tgt_tok = ["bonjour", "monde", "la", "ami"] # 4 target tokens (indices 0-3)
# Expected: src_unaligned = [3], tgt_unaligned = [3]
ARGS = {
"align_words": align_words,
"src_tok": src_tok,
"tgt_tok": tgt_tok,
}
- 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, ndim 2, 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_ner |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/ner.py code served (permissive licence) · get_code("99b73eb7e1a4905d") 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 torch
import numpy as np
torch.manual_seed(0)
# Analyzing the function:
# - nes: list of dicts with 'entity' and 'index' keys
# - token: list of lists (word_list for each word)
# - printwarn: boolean flag (not used in function body)
# The function processes NER (Named Entity Recognition) outputs
# Each ne dict has:
# - 'entity': string like 'B-PER', 'I-PER', 'O' (but 'O' causes assertion)
# - 'index': integer (1-indexed based on usage)
# token is used to map token indices to word indices
# Each word can have multiple sub-tokens (subword tokenization)
nes = [
{'entity': 'B-PER', 'index': 1},
{'entity': 'I-PER', 'index': 2},
{'entity': 'B-LOC', 'index': 3},
{'entity': 'I-LOC', 'index': 4},
{'entity': 'B-ORG', 'index': 5},
]
# token: each word can be split into multiple subword tokens
# For example, word 0 has 1 subtoken, word 1 has 2 subtokens, etc.
token = [
['token0'], # word 0: 1 subtoken (indices 1)
['token1', 'token1_'], # word 1: 2 subtokens (indices 2-3)
['token2'], # word 2: 1 subtoken (index 4)
['token3', 'token3_'], # word 3: 2 subtokens (indices 5-6)
['token4'], # word 4: 1 subtoken (index 7)
]
ARGS = {
'nes': nes,
'token': token,
'printwarn': False,
}
- 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 — 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
|
| insert_token_make_batchsents |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/entitylink.py code served (permissive licence) · get_code("fe80f19e05d4e058") 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
# Analyze the function:
# - tgt_tok: iterated over with enumerate, so needs to be a sequence of tokens (strings)
# - tlnetup: iterated over to unpack (s, e, t), so needs to be a list of tuples with 3 elements each
# where s and e are integers used for indexing comparison with i
# t is unpacked but not used in the function body
# Construct valid arguments
tgt_tok = ['hello', 'world', 'this', 'is', 'a', 'test']
# tlnetup: list of tuples (start_idx, end_idx, unused_value)
# Let's create a few examples with different start/end positions
tlnetup = [
(1, 3, 'label1'),
(0, 5, 'label2'),
(2, 4, 'label3'),
]
ARGS = {
'tgt_tok': tgt_tok,
'tlnetup': tlnetup,
}
- 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
|
| plot3 |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/plots.py code served (permissive licence) · get_code("cca6327af9af1e77") 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 Figure. 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 matplotlib.pyplot as plt
from matplotlib.figure import Figure
import numpy as np
torch.manual_seed(0)
# Define a minimal plot function that matches the expected signature
def dummy_plot_func(ax, lcompare, data, **kwargs):
"""Minimal plotting function that accepts the required arguments"""
ax.plot([1, 2, 3], [1, 2, 3])
ax.set_title(f"Plot with {len(lcompare)} items")
# Create minimal data structure
data = {
"values": torch.randn(2, 4),
"labels": ["a", "b"]
}
# Create comparison lists - two lists of items to compare
llcompare = [
["item1_a", "item1_b"],
["item2_a", "item2_b"],
["item3_a", "item3_b"]
]
# Create args for each subplot
largs = [
{"color": "red"},
{"color": "blue"},
{"color": "green"}
]
# Additional kwargs to pass through
kwargs_extra = {"linewidth": 2}
ARGS = {
"plot_func": dummy_plot_func,
"llcompare": llcompare,
"data": data,
"largs": largs,
"kwargs": kwargs_extra
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Figure — a Figure output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Figure 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
|
| plot6 |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/plots.py code served (permissive licence) · get_code("1b161f90a980b964") 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 module. 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 matplotlib.pyplot as plt
import numpy as np
torch.manual_seed(0)
# Define a simple plot function that will be passed as plot_func
def simple_plot_func(ax, lcompare, data, *args, **kwargs):
"""
A minimal plot function that accepts ax, lcompare, and data.
This function should work with the plot6 signature.
"""
x = np.linspace(0, 10, 100)
y = np.sin(x)
ax.plot(x, y, label=str(lcompare))
ax.set_title(f"Plot for {lcompare}")
ax.legend()
# Create llcompare: a list of 6 comparisons (since we have 2x3 grid)
llcompare = [
"compare_1",
"compare_2",
"compare_3",
"compare_4",
"compare_5",
"compare_6"
]
# Create data: can be any object, we'll use a simple dict
data = {
"values": torch.randn(2, 4),
"labels": ["label1", "label2"]
}
# Optional args and kwargs for the plot function
args_list = []
kwargs_dict = {
"color": "blue",
"linewidth": 2.0
}
ARGS = {
"plot_func": simple_plot_func,
"llcompare": llcompare,
"data": data,
"args": args_list,
"kwargs": kwargs_dict
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type module — a module output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a module 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
|
| plot8 |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/plots.py code served (permissive licence) · get_code("5983071885cc410d") 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 module. 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 matplotlib.pyplot as plt
from matplotlib.axes import Axes
torch.manual_seed(0)
# Define a simple plot function that will be called for each subplot
def simple_plot_func(ax, lcompare, data, *args, **kwargs):
"""Simple stand-in plot function that takes an axes object and data."""
ax.plot([1, 2, 3], [1, 2, 3])
ax.set_title(f"Plot {lcompare}")
# Create sample data - a small tensor
sample_data = torch.randn(2, 4)
# Create a list of compare items (one for each subplot, 8 items total for 2x4 grid)
llcompare = [
["compare_1a", "compare_1b"],
["compare_2a", "compare_2b"],
["compare_3a", "compare_3b"],
["compare_4a", "compare_4b"],
["compare_5a", "compare_5b"],
["compare_6a", "compare_6b"],
["compare_7a", "compare_7b"],
["compare_8a", "compare_8b"],
]
# Define ARGS dictionary with all parameters for plot8
ARGS = {
"plot_func": simple_plot_func,
"llcompare": llcompare,
"data": sample_data,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type module — a module output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a module 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
|
| print_span |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/show.py code served (permissive licence) · get_code("8c9acd0ab7ead2bd") 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 List
# Define ARGS dict with valid arguments for print_span function
ARGS = {
'lsrcbrack': [(0, 2), (4, 5)], # List of tuples representing index ranges
'srctok_orig': ['hello', 'world', 'this', 'is', 'a', 'test'], # List of string tokens
'color': 'GREEN' # Color name as string
}
- 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
|
| remove_duplicate_tuples |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/autoexpl/utils.py code served (permissive licence) · get_code("8d1d41b003e7a86e") 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 2, 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
# Analyze the function:
# - It takes a list `lst` as input
# - It iterates through elements (called `tup`)
# - For each element, it accesses `tup[:1]` (slicing the first element)
# - It checks if `tup[:1]` is in a set
# - It appends `tup` to result and adds `tup[:1]` to seen set
# The function appears to deduplicate based on the first element of each tuple
# Create a list of tuples where we can deduplicate by first element
# Use tuples with distinct first elements and varying second elements
lst = [
(1, 'a'),
(2, 'b'),
(1, 'c'), # duplicate first element, should be filtered
(3, 'd'),
(2, 'e'), # duplicate first element, should be filtered
(4, 'f'),
]
ARGS = {
'lst': lst
}
- 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 2, 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
|
| tup_range_to_idx |
Ran ran on a synthesized input |
h-j-han/automatic_explicitation/show.py code served (permissive licence) · get_code("f84f0926a1f7a503") 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 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
def tup_range_to_idx(tupleidxrange):
slne = []
for t in tupleidxrange:
s = t[0]
e = t[1]
for i in range(s, e + 1):
slne.append(i)
return slne
torch.manual_seed(0)
ARGS = {
'tupleidxrange': [(0, 2), (5, 7), (10, 12)]
}
- 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 int — 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
|