| _get2 |
Ran ran; our contract draft was wrong, not the code |
rspeer/langcodes/langcodes/language_distance.py code served (permissive licence) · get_code("87ef13f56a39c168") 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
torch.manual_seed(0)
# Construct a simple nested dictionary structure for testing _get2
dictionary = {
"level1_key": {
"level2_key": "found_value"
},
"another_key": {
"nested": "other_value"
}
}
# Set up arguments for _get2
# The function performs: dictionary.get(key1, {}).get(key2, default)
# It tries to get key1 from dictionary (defaulting to empty dict if not found)
# Then tries to get key2 from that result (defaulting to the provided default value)
ARGS = {
"dictionary": dictionary,
"key1": "level1_key",
"key2": "level2_key",
"default": "default_value"
}
- 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_colexification_graph |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/linking-datasets/colexification_graph.py code served (permissive licence) · get_code("6b629ba8d05d27b2") 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 Graph. 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 networkx as nx
from itertools import combinations
# Build a minimal concepts dictionary
concepts = {
'c001': {
'gloss': 'a domesticated mammal',
'synset_id': 'synset_001',
'n_babel_langs': 42
},
'c002': {
'gloss': 'a large domesticated mammal',
'synset_id': 'synset_002',
'n_babel_langs': 38
},
'c003': {
'gloss': 'a young dog',
'synset_id': 'synset_003',
'n_babel_langs': 35
},
'c004': {
'gloss': 'a feline animal',
'synset_id': 'synset_004',
'n_babel_langs': 40
},
}
# Build a minimal index dictionary
# Key: (language, lemma_lowercase)
# Value: list of (concept_id, original_lemma) tuples
index = {
('English', 'dog'): [('c001', 'dog'), ('c002', 'dog')],
('English', 'puppy'): [('c003', 'puppy')],
('French', 'chien'): [('c001', 'chien'), ('c003', 'chien'), ('c004', 'chien')],
('Spanish', 'gato'): [('c004', 'gato'), ('c002', 'gato')],
('German', 'katze'): [('c004', 'katze')],
}
ARGS = {
'concepts': concepts,
'index': index,
'max_polysemy': 5
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- networkx — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Graph — a Graph output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Graph output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| collect_codes |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/linking-datasets/link.py code served (permissive licence) · get_code("847c83bc6da9a368") 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 set. 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 zipfile
import csv
from pathlib import Path
# Create a temporary zip file with a CSV inside
temp_dir = tempfile.TemporaryDirectory()
temp_path = Path(temp_dir.name)
zip_path = temp_path / "test.zip"
# Create a zip file with a CSV file inside
with zipfile.ZipFile(zip_path, 'w') as zf:
csv_content = "code\tname\tdescription\n"
csv_content += "ABC123\tItem A\tFirst item\n"
csv_content += "DEF456\tItem B\tSecond item\n"
csv_content += "ABC123\tItem C\tDuplicate code\n"
csv_content += "GHI789\tItem D\tThird item\n"
zf.writestr("data.csv", csv_content)
ARGS = {
"zip_path": zip_path,
"inner_path": "data.csv",
"col_names": ["code", "name"],
"sep": "\t"
}
- 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 set — a set output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a set output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| collect_codes_etymon |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/linking-datasets/link.py code served (permissive licence) · get_code("a11bffd935e64e99") 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 set. 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 io
import zipfile
import tempfile
from pathlib import Path
# Create a temporary zip file with valid Etymon TSV data
temp_dir = tempfile.TemporaryDirectory()
temp_path = Path(temp_dir.name)
zip_file_path = temp_path / "etymon_data.zip"
# Create sample TSV content in the format: {lang}: {lemma}\t{relation}\t{lang}: {lemma}
tsv_content = """en: water\trelated\tfr: eau
de: wasser\tetymology\tnl: water
es: agua\tcognate\tit: acqua
pt: água\tsimilar\tro: apă"""
# Create the zip file with the TSV content
with zipfile.ZipFile(zip_file_path, 'w') as zf:
zf.writestr("etymon_data.tsv", tsv_content)
ARGS = {
"zip_path": zip_file_path,
"inner_path": "etymon_data.tsv"
}
- 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 set — a set output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a set output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| collect_codes_phonotacticon |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/linking-datasets/link.py code served (permissive licence) · get_code("3bb7ae9d1e8b44a4") 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 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 csv
import io
import zipfile
from pathlib import Path
import tempfile
# Create a temporary zip file with CSV data containing Glottocodes and ISO codes
temp_dir = tempfile.mkdtemp()
zip_path = Path(temp_dir) / "test.zip"
# Create CSV content with sample data
csv_content = """Glottocode,ISO,Language
abcd1234,eng,English
efgh5678,fra,French
ijkl9012,deu,German
"""
# Create the zip file with the CSV inside
with zipfile.ZipFile(zip_path, 'w') as zf:
zf.writestr("phonotacticon.csv", csv_content)
# Create a minimal resolver (not used in the function, but required as parameter)
class MinimalResolver:
pass
resolver = MinimalResolver()
ARGS = {
"zip_path": zip_path,
"inner_path": "phonotacticon.csv",
"resolver": resolver
}
- 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 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| format_languoid_structure |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/src/qq/release.py code served (permissive licence) · get_code("92f5f4720885c343") 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 MockLanguoid:
def __init__(self):
self.name = "English"
self.iso_639_3 = "eng"
self.bcp_47 = "en"
self.iso_639_2b = "eng"
self.glottocode = "stan1293"
self.wikidata_id = "Q1860"
self.endonym = "English"
self.speaker_count = 1500000000
self.level = MockLevel("language")
self.scope = "individual"
self.status = "living"
self.is_macrolanguage = False
self.endangerment_status = MockEndangermentStatus("not_endangered")
self.script_codes = ["Latn", "Arab"]
self.parent = MockLanguoid_Parent()
self.family_tree = [MockLanguoid_Ancestor(), MockLanguoid_Ancestor2()]
self.children = [
MockChild("English Creole 1"),
MockChild("English Creole 2"),
MockChild("English Creole 3"),
MockChild("English Creole 4"),
MockChild("English Creole 5"),
MockChild("English Creole 6"),
]
self.scripts = [
MockScript("Latin", "Latn"),
MockScript("Arabic", "Arab"),
]
self.canonical_scripts = self.scripts
self.regions = [
MockRegion("United Kingdom", "GB"),
MockRegion("United States", "US"),
MockRegion("Canada", "CA"),
MockRegion("Australia", "AU"),
MockRegion("Ireland", "IE"),
MockRegion("New Zealand", "NZ"),
]
def nllb_codes(self, use_bcp_47=False):
if use_bcp_47:
return ["en_Latn", "en_Arab"]
return ["eng"]
def descendants(self):
return [MockChild(f"Descendant {i}") for i in range(42)]
class MockLevel:
def __init__(self, value):
self.value = value
class MockEndangermentStatus:
def __init__(self, value):
self.value = value
class MockLanguoid_Parent:
def __init__(self):
self.name = "Indo-European"
self.iso_639_3 = None
self.glottocode = "indo1319"
class MockLanguoid_Ancestor:
def __init__(self):
self.name = "Proto-Indo-European"
self.level = MockLevel("proto-language")
class MockLanguoid_Ancestor2:
def __init__(self):
self.name = "Germanic"
self.level = MockLevel("language_family")
class MockChild:
def __init__(self, name):
self.name = name
self.iso_639_3 = "xxx"
self.glottocode = "xxxx1234"
class MockScript:
def __init__(self, name, iso_15924):
self.name = name
self.iso_15924 = iso_15924
class MockRegion:
def __init__(self, name, country_code):
self.name = name
self.country_code = country_code
ARGS = {
"languoid": MockLanguoid()
}
- 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
|
| lazy_load |
Ran ran; our contract draft was wrong, not the code |
pycountry/pycountry/src/pycountry/db.py pointer only (licence: LGPL-2.1) · get_code("f850e5c174c44a84") How it ranThe body of this sample is withheld: LGPL-2.1, as GitHub detects it on this paper's repository, pycountry/pycountry, is not in the permissive set Syntology serves inline. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded. |
| load_babelnet |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/linking-datasets/colexification_graph.py code served (permissive licence) · get_code("0d082022d3ceb3b3") 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 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 csv
import io
import zipfile
from collections import defaultdict
from pathlib import Path
import tempfile
import os
# Create a temporary zip file with a valid BabelNet TSV structure
temp_dir = tempfile.mkdtemp()
zip_path = Path(temp_dir) / "babelnet.zip"
tsv_filename = "babelnet.tsv"
# Create TSV content
tsv_content = """concept_id language lemma source concept_gloss synset_id
bn_001 en apple WIKT_1 a fruit wn30_i1234
bn_001 en apple fruit WIKT_2 a fruit wn30_i1234
bn_001 fr pomme OMWN_1 un fruit wn30_i1234
bn_002 en dog WN_1 a canine animal wn30_i5678
bn_002 en canine MCR_1 a canine animal wn30_i5678
bn_002 de Hund OEWN_1 ein Hund wn30_i5678
bn_003 en WIKT_3 empty lemma test wn30_i9999
bn_004 en under_score SLOWNET_1 lemma with underscore wn30_i2222
bn_005 en table INVALID_SOURCE_1 furniture wn30_i3333
bn_005 en table WN_2 furniture wn30_i3333
bn_006 en run WIKT_1 to move fast wn30_i4444
bn_006 en run WIKT_2 to move fast wn30_i4444
bn_006 en run WIKT_3 to move fast wn30_i4444
bn_006 en run WIKT_4 to move fast wn30_i4444
bn_006 en run WIKT_5 to move fast wn30_i4444
bn_006 en sprint WIKT_6 to move fast wn30_i4444
"""
# Create zip file with the TSV
with zipfile.ZipFile(zip_path, 'w') as zf:
zf.writestr(tsv_filename, tsv_content)
ARGS = {
"zip_path": zip_path,
"inner_tsv": tsv_filename,
}
- 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 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_concepticon |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/linking-datasets/concept_graph.py code served (permissive licence) · get_code("6621368410a34f5d") 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 csv
import io
import zipfile
from pathlib import Path
from collections import defaultdict
import tempfile
# Create a temporary zip file with TSV data
temp_dir = tempfile.TemporaryDirectory()
zip_path = Path(temp_dir.name) / "concepticon.zip"
# Create sample TSV content
tsv_content = """concept_id\tlanguage\tlemma\tconcept_gloss\tsynset_id
c001\ten\tdog\tcanine animal\tss001
c001\tde\tHund\tcanine animal\tss001
c002\ten\tcat\tfeline animal\tss002
c002\tfr\tchat\tfeline animal\tss002
c002\ten\tkitty\tfeline animal\tss002
"""
# Write the zip file with TSV inside
with zipfile.ZipFile(zip_path, 'w') as zf:
zf.writestr('concepticon.tsv', tsv_content)
ARGS = {
'zip_path': zip_path,
'inner_tsv': 'concepticon.tsv'
}
- 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
|
| load_ratings |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/linking-datasets/concept_graph.py code served (permissive licence) · get_code("75d6a7f5a07a386a") 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 csv
import io
import zipfile
from collections import defaultdict
from pathlib import Path
import tempfile
import os
# Create a temporary zip file with TSV data for testing
temp_dir = tempfile.mkdtemp()
zip_path = Path(temp_dir) / "test_data.zip"
# Create sample TSV data
tsv_content_1 = "CONCEPTICON_ID\trating_col1\trating_col2\tother_col\n"
tsv_content_1 += "c001\t3.5\t4.2\tsome_value\n"
tsv_content_1 += "c002\t2.1\t3.8\tanother_value\n"
tsv_content_2 = "CONCEPTICON_ID\trating_col1\n"
tsv_content_2 += "c001\t2.5\n"
tsv_content_2 += "c003\t1.9\n"
# Create zip with proper directory structure
with zipfile.ZipFile(zip_path, 'w') as zf:
zf.writestr('datasets/dataset1/data.tsv', tsv_content_1)
zf.writestr('datasets/dataset2/data.tsv', tsv_content_2)
# Create var_meta dict with metadata for rated columns
var_meta = {
('dataset1', 'rating_col1'): {'type': 'semantic_similarity', 'lang': 'en'},
('dataset1', 'rating_col2'): {'type': 'semantic_similarity', 'lang': 'en'},
('dataset2', 'rating_col1'): {'type': 'relatedness', 'lang': 'fr'},
}
ARGS = {
'zip_path': zip_path,
'var_meta': var_meta,
}
- 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
|
| load_variable_metadata |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/linking-datasets/concept_graph.py code served (permissive licence) · get_code("dea05c7553d830d5") 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 csv
import io
import zipfile
from pathlib import Path
from collections import defaultdict
import tempfile
# Create a temporary zip file with a valid TSV inside
def create_test_zip():
temp_dir = tempfile.mkdtemp()
zip_path = Path(temp_dir) / "test.zip"
# Create TSV content
tsv_content = """DATASET\tNAME\tTYPE\tLANGUAGE\tNORARE
dataset1\tCOL_VALENCE_MEAN\tvalence\tenglish\tratings
dataset1\tCOL_VALENCE_MIN\tvalence\tenglish\tratings
dataset1\tCOL_AROUSAL_MEAN\tarousal\tenglish\tratings
dataset2\tSPANISH_AOA_MEAN\tAoA\tspanish\tnorms
dataset2\tSPANISH_AOA_MAX\tAoA\tspanish\tnorms
dataset3\tIMAGEABILITY\timageability\tenglish\tratings
dataset4\tFREQUENCY_MEAN\tfrequency\tenglish\tnorms
dataset4\tFREQUENCY_LOG\tfrequency\tenglish\tnorms
dataset5\tDOMINANCE\tdominance\tenglish\tratings
dataset5\tEMOTIONALITY_MEAN\temotionality\tenglish\tnorms
dataset5\tEMOTIONALITY_MAX\temotionality\tenglish\tnorms
dataset6\tFAMILIARITY\tfamiliarity\tenglish\tratings
dataset6\tCONCRETENESS_MEAN\tconcreteness\tenglish\tratings
dataset6\tCONCRETENESS_SHORT\tconcreteness\tenglish\tratings
other_row\tOTHER_COL\tunknown_type\tenglish\tother
"""
# Create zip file with TSV
with zipfile.ZipFile(zip_path, 'w') as zf:
zf.writestr("norare.tsv", tsv_content)
return zip_path
zip_path = create_test_zip()
ARGS = {
'zip_path': zip_path,
'inner_tsv': 'norare.tsv'
}
- 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
|
| parse_language_tag |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/src/qq/bcp47.py code served (permissive licence) · get_code("636fc22b10df1422") 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 ParsedLanguageTag. 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 dataclasses import dataclass
@dataclass(frozen=True)
class ParsedLanguageTag:
"""Simple parsed result of a BCP 47 code.
This intentionally does not model the full BCP 47 parts, only the
primary language subtag and script/region pieces such as ``sr-Latn-RS`` and ``deu_Latn``.
"""
original: str
normalized: str
language: str | None
script: str | None = None
region: str | None = None
def _is_region_subtag(subtag: str) -> bool:
return len(subtag) == 2 and subtag.isalpha() or (len(subtag) == 3 and subtag.isdigit())
def parse_language_tag(tag: str) -> ParsedLanguageTag:
"""Parse a BCP-47-like tag and return its language/script/region pieces.
The parser is deliberately permissive:
- accepts ``-`` and ``_`` separators;
- normalizes language/script/region casing;
- ignores extensions/private-use subtags;
- returns ``language=None`` for private-use-only tags such as ``x-foo``.
"""
original = tag
parts = [p for p in tag.replace('_', '-').split('-') if p]
if not parts:
return ParsedLanguageTag(original=original, normalized='', language=None)
language = parts[0].lower()
if language == 'x':
normalized = '-'.join(('x', *(p.lower() for p in parts[1:])))
return ParsedLanguageTag(original=original, normalized=normalized, language=None)
script: str | None = None
region: str | None = None
i = 1
if i < len(parts) and len(parts[i]) == 4 and parts[i].isalpha():
script = parts[i].title()
i += 1
if i < len(parts) and _is_region_subtag(parts[i]):
region = parts[i].upper()
i += 1
normalized_parts = [language]
if script:
normalized_parts.append(script)
if region:
normalized_parts.append(region)
return ParsedLanguageTag(original=original, normalized='-'.join(normalized_parts), language=language, script=script, region=region)
ARGS = {
"tag": "sr-Latn-RS"
}
- 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 ParsedLanguageTag — a ParsedLanguageTag output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ParsedLanguageTag 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
|
| script |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/latex-tables/generate.py code served (permissive licence) · get_code("d090146fe9795fc9") 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 MockScript:
def __init__(self, iso_15924):
self.iso_15924 = iso_15924
class MockLanguage:
def __init__(self, canonical_scripts=None, script_codes=None):
self.canonical_scripts = canonical_scripts if canonical_scripts is not None else []
self.script_codes = script_codes if script_codes is not None else []
# Test case 1: language with canonical_scripts
lang_with_canonical = MockLanguage(
canonical_scripts=[MockScript('Latn')],
script_codes=['Zyyy']
)
ARGS = {
'lang': lang_with_canonical
}
- 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
|
| speakers |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/latex-tables/generate.py code served (permissive licence) · get_code("299f41d69a5fec21") 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.
# The function 'speakers' takes an optional integer n and returns a formatted string representation
# It doesn't use any complex objects, just needs an integer or None
ARGS = {
'n': 1500000
}
- 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
|
| tex |
Ran ran; our contract draft was wrong, not the code |
WPoelman/qwanqwa/case-studies/latex-tables/generate.py code served (permissive licence) · get_code("cac6fc4f14bc78f6") 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 tex(s: str | None) -> str:
if not s:
return '---'
return s.replace('&', '\\&').replace('%', '\\%').replace('$', '\\$').replace('#', '\\#').replace('_', '\\_')
ARGS = {
's': 'Hello & World % test $ with # special _ chars'
}
- 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
|
| tint |
Ran ran, honoured the contract we drafted |
WPoelman/qwanqwa/case-studies/huggingface-audit/analyze.py code served (permissive licence) · get_code("74e807948c899ee4") 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 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
# Analyzing the function:
# - color: str parameter that should be a valid hex color (e.g., "#RRGGBB")
# - white_mix: float parameter with default 0.18
# The function extracts RGB values from hex string and mixes with white
ARGS = {
"color": "#FF5733",
"white_mix": 0.18
}
- 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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| tint |
Ran ran, honoured the contract we drafted |
WPoelman/qwanqwa/case-studies/identifier-coverage/plot.py code served (permissive licence) · get_code("3a40af0b6b12cc5b") 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 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 matplotlib as mpl
ARGS = {
"color": "blue",
"white_mix": 0.18
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| _tuple_distance |
Not yet run unverified (harvested, no recorded run) |
rspeer/langcodes/langcodes/language_distance.py code served (permissive licence) · get_code("54fc5f9ea1714cfd") How it ran |
| fetch_hf_metadata |
Not yet run unverified (harvested, no recorded run) |
WPoelman/qwanqwa/case-studies/huggingface-audit/analyze.py code served (permissive licence) · get_code("8fc94f22a36215f6") How it ran |