| classifyfolder |
Ran ran on a synthesized input |
jim-schwoebel/allie/models/load.py code served (permissive licence) · get_code("af5e4babbb921931") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import json
import pickle
import time
import sys
import shutil
# Create a mock listdir with various file types
mock_listdir = [
'song1.mp3',
'song2.wav',
'image1.png',
'image2.jpg',
'document.txt',
'video1.mp4',
'video2.avi',
'data.csv',
'readme.md'
]
ARGS = {
'listdir': mock_listdir
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| evaluate_on_rung |
Ran ran on a synthesized input |
PGijsbers/gama/gama/search_methods/asha.py code served (permissive licence) · get_code("57c8a0339bc269d0") 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 MockEvaluation. 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)
class MockIndividual:
def __init__(self):
self.meta = {}
class MockEvaluation:
def __init__(self, individual, error=None):
self.individual = individual
self.error = error
def mock_evaluate_individual(individual, *args, **kwargs):
return MockEvaluation(individual, error=None)
individual = MockIndividual()
rung = 1
max_rung = 3
evaluate_individual = mock_evaluate_individual
ARGS = {
'individual': individual,
'rung': rung,
'max_rung': max_rung,
'evaluate_individual': evaluate_individual,
'args': (),
'kwargs': {'subsample': 0.5}
}
- 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 MockEvaluation — a MockEvaluation output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MockEvaluation 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
|
| fast_non_dominated_sort |
Ran ran on a synthesized input |
PGijsbers/gama/gama/genetic_programming/nsga2.py code served (permissive licence) · get_code("ee60026f2ff14ace") 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. 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 NSGAMeta:
"""A helper class for comparing data points for NSGA2."""
def __init__(self, obj: object, metrics):
self.obj = obj
self.values = tuple((m(obj) for m in metrics))
self.rank = 0
self.distance = 0.0
self.dominating = []
self.domination_counter = 0
def dominates(self, other: 'NSGAMeta') -> bool:
for self_val, other_val in zip(self.values, other.values):
if self_val <= other_val:
return False
return True
def crowd_compare(self, other: 'NSGAMeta') -> int:
"""Favor higher rank, if equal, favor less crowded."""
self_better = self.rank < other.rank or (self.rank == other.rank and self.distance > other.distance)
return -1 if self_better else 1
torch.manual_seed(0)
# Create simple objects to optimize
obj1 = {"id": 1, "value": 5.0}
obj2 = {"id": 2, "value": 3.0}
obj3 = {"id": 3, "value": 7.0}
obj4 = {"id": 4, "value": 2.0}
# Define metrics (callables that extract values from objects)
def metric1(obj):
return obj["value"]
def metric2(obj):
return -obj["value"] * 0.5
metrics = [metric1, metric2]
# Create NSGAMeta instances
nsga_meta_1 = NSGAMeta(obj1, metrics)
nsga_meta_2 = NSGAMeta(obj2, metrics)
nsga_meta_3 = NSGAMeta(obj3, metrics)
nsga_meta_4 = NSGAMeta(obj4, metrics)
# Create population
P = [nsga_meta_1, nsga_meta_2, nsga_meta_3, nsga_meta_4]
ARGS = {
"P": P
}
- 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 — a list 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
|
| fast_non_dominated_sort |
Ran ran on a synthesized input |
openml-labs/gama/gama/genetic_programming/nsga2.py code served (permissive licence) · get_code("b3f0bed67a0d0b50") 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. 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 itertools
from typing import List, Any, Callable
class NSGAMeta:
"""A helper class for comparing data points for NSGA2."""
def __init__(self, obj: object, metrics: List[Callable]):
self.obj = obj
self.values = tuple((m(obj) for m in metrics))
self.rank = 0
self.distance = 0.0
self.dominating: List['NSGAMeta'] = []
self.domination_counter = 0
def dominates(self, other: 'NSGAMeta') -> bool:
return all((self_val > other_val for self_val, other_val in zip(self.values, other.values)))
def crowd_compare(self, other: 'NSGAMeta') -> int:
"""Favor higher rank, if equal, favor less crowded."""
self_better = self.rank < other.rank or (self.rank == other.rank and self.distance > other.distance)
return -1 if self_better else 1
def fast_non_dominated_sort(P: List[NSGAMeta]) -> List[List[NSGAMeta]]:
"""Sorts P into Pareto fronts."""
fronts: List[List[NSGAMeta]] = [[]]
for p, q in itertools.combinations(P, 2):
if p.dominates(q):
p.dominating.append(q)
q.domination_counter += 1
elif q.dominates(p):
q.dominating.append(p)
p.domination_counter += 1
for p in P:
if p.domination_counter == 0:
p.rank = 1
fronts[0].append(p)
i = 0
while fronts[i] != []:
fronts.append([])
for p in fronts[i]:
for q in p.dominating:
q.domination_counter -= 1
if q.domination_counter == 0:
q.rank = i + 1
fronts[i + 1].append(q)
i += 1
return fronts
# Create simple objects and metrics for testing
obj1 = {"id": 1}
obj2 = {"id": 2}
obj3 = {"id": 3}
obj4 = {"id": 4}
# Define metrics that return numeric values
metric1 = lambda obj: obj["id"] * 2
metric2 = lambda obj: obj["id"] * 3
# Create NSGAMeta instances
meta1 = NSGAMeta(obj1, [metric1, metric2])
meta2 = NSGAMeta(obj2, [metric1, metric2])
meta3 = NSGAMeta(obj3, [metric1, metric2])
meta4 = NSGAMeta(obj4, [metric1, metric2])
# Create population for fast_non_dominated_sort
P = [meta1, meta2, meta3, meta4]
ARGS = {
"P": P
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list — a list 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
|
| format_y |
Ran ran on a synthesized input |
PGijsbers/gama/gama/data_formatting.py code served (permissive licence) · get_code("0d39f4175f94181d") 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 Series. 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 numpy as np
import pandas as pd
# Test case 1: numpy array 1D
y_1d = np.array([0, 1, 0, 1])
# Test case 2: numpy array 2D with multiple columns (will be argmax'd)
y_2d_multi = np.array([[0.1, 0.9], [0.8, 0.2], [0.3, 0.7]])
# Test case 3: numpy array 2D with single column (will be squeezed)
y_2d_single = np.array([[0], [1], [0]])
# Test case 4: pandas Series
y_series = pd.Series([0, 1, 0, 1])
# Test case 5: pandas DataFrame
y_df = pd.DataFrame({'target': [0, 1, 0, 1]})
ARGS = {
"y": y_1d,
"y_type": pd.Series
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Series — a Series output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Series output the recorded ndim 1 and dtype family int 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_y |
Ran ran on a synthesized input |
openml-labs/gama/gama/data_formatting.py code served (permissive licence) · get_code("4666e8ed5c65fb12") 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 Series. 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 numpy as np
import pandas as pd
# Test case 1: numpy array 1D
y_1d = np.array([0, 1, 2, 1, 0])
# Test case 2: numpy array 2D with multiple classes
y_2d_multi = np.array([[0.9, 0.1], [0.2, 0.8], [0.3, 0.7]])
# Test case 3: numpy array 2D with single class
y_2d_single = np.array([[1.0], [0.5], [0.8]])
# Test case 4: pandas Series
y_series = pd.Series([0, 1, 2, 1, 0])
# Test case 5: pandas DataFrame
y_dataframe = pd.DataFrame({'target': [0, 1, 2, 1, 0]})
ARGS = {
'y': y_1d,
'y_type': pd.Series
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Series — a Series output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Series output the recorded ndim 1 and dtype family int 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_labels |
Ran ran on a synthesized input |
jim-schwoebel/allie/features/audio_features/yamnet_features.py code served (permissive licence) · get_code("0659761c261891b8") 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)
ARGS = {
'vector': [1, 2, 3, 4, 5],
'label': 'sample_',
'label2': 'type_A'
}
- 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
|
| load_csv_header |
Ran ran on a synthesized input |
PGijsbers/gama/gama/data_loading.py code served (permissive licence) · get_code("520cd8123a24aacd") 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 tempfile
import os
# Create a temporary CSV file with a header
temp_dir = tempfile.mkdtemp()
csv_file_path = os.path.join(temp_dir, "test_data.csv")
with open(csv_file_path, 'w') as f:
f.write("name,age,city\n")
f.write("Alice,30,NYC\n")
f.write("Bob,25,LA\n")
ARGS = {
'file_path': csv_file_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| most_common |
Ran ran; our contract draft was wrong, not the code |
jim-schwoebel/allie/models/load.py code served (permissive licence) · get_code("1deecc25893dafad") 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
torch.manual_seed(0)
# Analyze the function:
# - most_common(lst) takes a list parameter
# - It uses set(lst) to get unique items
# - It uses lst.count() method on items in the set
# - It returns the item with the maximum count
# - The list should contain hashable items that can be counted
# Create a simple list with repeated items
lst = [1, 2, 2, 3, 2, 4, 1, 2, 5]
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 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
|
| nsga2 |
Ran ran on a synthesized input |
PGijsbers/gama/gama/genetic_programming/nsga2.py code served (permissive licence) · get_code("a040787fe7e3a043") 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 numpy as np
# Create a simple population of objects (dicts with some properties)
population = [
{"accuracy": 0.85, "loss": 0.15, "speed": 0.9},
{"accuracy": 0.82, "loss": 0.18, "speed": 0.95},
{"accuracy": 0.88, "loss": 0.12, "speed": 0.85},
{"accuracy": 0.80, "loss": 0.20, "speed": 1.0},
{"accuracy": 0.86, "loss": 0.14, "speed": 0.88},
{"accuracy": 0.84, "loss": 0.16, "speed": 0.92},
]
# Define metrics (callables that extract float values from population objects)
# We want to maximize accuracy and speed, minimize loss
metrics = [
lambda obj: obj["accuracy"], # higher is better
lambda obj: obj["speed"], # higher is better
lambda obj: -obj["loss"], # lower loss is better, so negate
]
n = 3
return_meta = False
ARGS = {
"population": population,
"n": n,
"metrics": metrics,
"return_meta": return_meta,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — 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
|
| nsga2 |
Ran ran on a synthesized input |
openml-labs/gama/gama/genetic_programming/nsga2.py code served (permissive licence) · get_code("8e229aa4f8a8f56d") 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 numpy as np
# Create a simple population of objects with numerical properties
class Individual:
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
# Create a small population
population = [
Individual(1.0, 2.0, 3.0),
Individual(2.0, 1.5, 2.5),
Individual(1.5, 3.0, 2.0),
Individual(3.0, 1.0, 1.5),
Individual(2.5, 2.5, 2.5),
Individual(0.5, 3.5, 3.5),
]
# Define metrics as callables that extract numeric values from individuals
metrics = [
lambda ind: ind.x,
lambda ind: ind.y,
lambda ind: -ind.z, # Negate z to demonstrate multi-objective optimization
]
# Number of individuals to select
n = 3
# Return meta information or not
return_meta = False
ARGS = {
"population": population,
"n": n,
"metrics": metrics,
"return_meta": return_meta,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — 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
|
| nsga2_select |
Ran ran on a synthesized input |
PGijsbers/gama/gama/genetic_programming/nsga2.py code served (permissive licence) · get_code("a18c1c1f6a83f5ae") 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 random
import numpy as np
# Set seed for reproducibility
random.seed(42)
np.random.seed(42)
# Create a simple population of objects
# Each object will be a dict with some properties
class SimpleIndividual:
def __init__(self, x, y):
self.x = x
self.y = y
# Create a population of 10 individuals
population = [SimpleIndividual(x=random.uniform(0, 10), y=random.uniform(0, 10)) for _ in range(10)]
# Define metrics as callables that extract values from individuals
# We want to minimize both x and y (so we negate them to turn minimization into maximization for NSGA2)
metric1 = lambda ind: -ind.x # Negative because we want to maximize (for domination)
metric2 = lambda ind: -ind.y
metrics = [metric1, metric2]
# Number of pairs to select
n = 4
ARGS = {
'population': population,
'n': n,
'metrics': metrics
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — 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
|
| nsga2_select |
Ran ran on a synthesized input |
openml-labs/gama/gama/genetic_programming/nsga2.py code served (permissive licence) · get_code("a7f96752452ada1c") 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 3, 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 random
import numpy as np
def metric_1(obj):
"""First metric: maximize value at index 0"""
return obj[0]
def metric_2(obj):
"""Second metric: maximize value at index 1"""
return obj[1]
def metric_3(obj):
"""Third metric: maximize value at index 2"""
return obj[2]
# Create a population of simple numeric tuples
population = [
(1.0, 2.0, 3.0),
(2.0, 1.5, 2.5),
(1.5, 3.0, 1.0),
(3.0, 2.5, 2.0),
(2.5, 2.5, 2.5),
(1.0, 1.0, 1.0),
]
# Define metrics as callables
metrics = [metric_1, metric_2, metric_3]
# Number of pairs to select
n = 2
ARGS = {
'population': population,
'n': n,
'metrics': metrics,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 3, 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
|
| numpy_to_dataframe |
Ran ran on a synthesized input |
PGijsbers/gama/gama/data_formatting.py code served (permissive licence) · get_code("c2b84360c1f09a1d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned DataFrame. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import pandas as pd
# Create a simple numpy array to pass to numpy_to_dataframe
# Mix of integer and float values to test the categorical inference
x = np.array([
[1, 2, 5, 10],
[1, 3, 5, 20],
[2, 2, 6, 10],
[3, 4, 7, 30]
], dtype=np.int64)
ARGS = {
'x': x
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 and dtype family int 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
|
| prev_dir |
Ran ran on a synthesized input |
jim-schwoebel/allie/models/load.py code served (permissive licence) · get_code("8e13be73f784da6b") 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
def prev_dir(directory):
g = directory.split('/')
dir_ = ''
for i in range(len(g)):
if i != len(g) - 1:
if i == 0:
dir_ = dir_ + g[i]
else:
dir_ = dir_ + '/' + g[i]
return dir_
ARGS = {
'directory': '/home/user/documents/file.txt'
}
- 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
|
| series_looks_categorical |
Ran ran on a synthesized input |
PGijsbers/gama/gama/data_formatting.py code served (permissive licence) · get_code("8424920875ff39be") 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 pandas as pd
import numpy as np
from pandas.core.dtypes.common import is_numeric_dtype
# Create test series for the function
# Test case 1: object dtype (should return True)
series_object = pd.Series(['a', 'b', 'c', 'a', 'b'])
# Test case 2: integer dtype with <= 10 unique values (should return True)
series_int_categorical = pd.Series([1, 2, 3, 1, 2, 3, 1, 2], dtype='int64')
# Test case 3: float dtype with integer-like values and <= 10 unique values (should return True)
series_float_categorical = pd.Series([1.0, 2.0, 3.0, 1.0, 2.0, 3.0], dtype='float64')
# Test case 4: numeric dtype with > 10 unique values (should return False)
series_numeric_many = pd.Series(np.arange(20), dtype='int64')
# Test case 5: float dtype with non-integer values (should return False)
series_float_continuous = pd.Series([1.5, 2.7, 3.2, 4.1], dtype='float64')
# Use the first one as the main test case
ARGS = {
'series': series_int_categorical
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — 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
|
| sniff_csv_meta |
Ran ran on a synthesized input |
PGijsbers/gama/gama/data_loading.py code served (permissive licence) · get_code("cf3c99ff20bab310") 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 tempfile
import os
# Create a temporary CSV file with valid content
temp_dir = tempfile.mkdtemp()
temp_csv_path = os.path.join(temp_dir, "test.csv")
# Write a sample CSV file with header and comma delimiter
with open(temp_csv_path, 'w', newline='') as f:
writer = csv.writer(f, delimiter=',')
writer.writerow(['name', 'age', 'city'])
writer.writerow(['Alice', '30', 'New York'])
writer.writerow(['Bob', '25', 'Los Angeles'])
writer.writerow(['Charlie', '35', 'Chicago'])
ARGS = {
'file_path': temp_csv_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, 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
|