| add_margin |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/image.py code served (permissive licence) · get_code("69866daba6f33b37") 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 Image. 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
from PIL import Image
import numpy as np
torch.manual_seed(0)
# Create a small test PIL image
pil_img = Image.new('RGB', (10, 8), color=(255, 100, 50))
ARGS = {
'pil_img': pil_img,
'top': 5,
'right': 7,
'bottom': 3,
'left': 4,
'color': (200, 150, 100)
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 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
|
| build_and_load_model |
Ran ran; our contract draft was wrong, not the code |
marl/crepe/crepe/core.py code served (permissive licence) · get_code("0478670b3c919823") 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 Functional. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import tempfile
from unittest.mock import patch, MagicMock
# Create a temporary directory to act as the package directory
temp_dir = tempfile.mkdtemp()
# Create mock .h5 files so load_weights doesn't fail
# We'll patch the load_weights method to do nothing
def mock_load_weights(self, filepath):
pass
ARGS = {
'model_capacity': 'tiny'
}
# Patch the load_weights method to prevent actual file I/O
import tensorflow.keras.models
original_load_weights = tensorflow.keras.models.Model.load_weights
tensorflow.keras.models.Model.load_weights = mock_load_weights
# Also patch os.path.dirname and os.path.realpath to return our temp dir
original_dirname = os.path.dirname
original_realpath = os.path.realpath
def mock_dirname(path):
return temp_dir
def mock_realpath(path):
return os.path.join(temp_dir, os.path.basename(path))
os.path.dirname = mock_dirname
os.path.realpath = mock_realpath
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Functional — a Functional output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Functional 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
|
| calculate_iou |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/metrics.py code served (permissive licence) · get_code("b87e5ad31fa0cad5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
# Set random seed for reproducibility
torch.manual_seed(0)
# Define bounding boxes in format (x1, y1, x2, y2)
# box1: top-left at (10, 20), bottom-right at (50, 60)
box1 = (10, 20, 50, 60)
# box2: top-left at (30, 40), bottom-right at (70, 80)
# This box overlaps with box1
box2 = (30, 40, 70, 80)
ARGS = {
"box1": box1,
"box2": box2,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| center_crop |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/image.py code served (permissive licence) · get_code("d6fe3eeba94bee55") 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 Image. 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 PIL import Image
import numpy as np
# Create a test image: 800x600 pixels (wider than tall)
# This will be center-cropped to a 600x600 square
img_array = np.random.randint(0, 256, (600, 800, 3), dtype=np.uint8)
test_image = Image.fromarray(img_array, mode='RGB')
ARGS = {
'im': test_image
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 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
|
| compute_intersection_1d |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/metrics.py code served (permissive licence) · get_code("5e9b6432446d547d") 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
torch.manual_seed(0)
# compute_intersection_1d takes two parameters: x and y
# Both are used with sorted() and then unpacked into two values each
# They should be sequences (lists, tuples, or similar) of numeric values
# The function sorts them and computes 1D interval intersection
x = [1, 5]
y = [3, 7]
ARGS = {
"x": x,
"y": y
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_union_1d |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/metrics.py code served (permissive licence) · get_code("58f2e9c573ba8489") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# The function compute_union_1d takes two parameters: x and y
# It expects them to be sequences/iterables that can be sorted and indexed
# It calls sorted(x) and sorted(y), then unpacks into two elements each
# So x and y should be sequences of length 2 (or convertible to length 2)
x = [1.0, 5.0]
y = [3.0, 7.0]
ARGS = {
"x": x,
"y": y
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| define_axes |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/demo/util.py code served (permissive licence) · get_code("174fc5323ab98cbb") 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 matplotlib.pyplot as plt
ARGS = {
'figsize': (13, 4),
'width_ratios': [0.22, 0.78]
}
- 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 — 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
|
| load_json |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/io.py code served (permissive licence) · get_code("f2e5cc3d297dbfda") 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 json
import tempfile
import os
# Create a temporary JSON file with valid test data
temp_dir = tempfile.mkdtemp()
test_json_path = os.path.join(temp_dir, "test.json")
test_data = {
"key1": "value1",
"key2": [1, 2, 3],
"key3": {"nested": "dict"}
}
with open(test_json_path, 'w') as f:
json.dump(test_data, f)
ARGS = {
"path": test_json_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_pkl |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/io.py code served (permissive licence) · get_code("a7be5e2bbedb930e") 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 pickle
import tempfile
import os
# Create a temporary pickle file for testing
temp_dir = tempfile.gettempdir()
test_data = {"key": "value", "number": 42, "list": [1, 2, 3]}
# Write test data to a pickle file
pkl_path = os.path.join(temp_dir, "test_load.pkl")
with open(pkl_path, 'wb') as f:
pickle.dump(test_data, f)
ARGS = {
'path': pkl_path,
'encoding': 'ascii'
}
- 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_yml |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/io.py code served (permissive licence) · get_code("5b21eaf9ef52a0da") 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 os
import tempfile
import yaml
# Create a temporary YAML file for testing
temp_dir = tempfile.mkdtemp()
yaml_file_path = os.path.join(temp_dir, "test_config.yml")
# Write a simple YAML file
test_data = {
'param1': 'value1',
'param2': 42,
'param3': [1, 2, 3],
'nested': {
'key': 'value'
}
}
with open(yaml_file_path, 'w') as f:
yaml.dump(test_data, f)
ARGS = {
'path': yaml_file_path,
'loader_type': 'default'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- yaml — 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
|
| output_path |
Ran ran; our contract draft was wrong, not the code |
marl/crepe/crepe/core.py code served (permissive licence) · get_code("782c3ee036f8a2e1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import re
ARGS = {
'file': '/path/to/audio.wav',
'suffix': '.txt',
'output_dir': '/output'
}
- 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
|
| pad_to_square |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/image.py code served (permissive licence) · get_code("78cfceace594ec65") 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 Image. 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 PIL import Image
import numpy as np
# Create a small PIL Image for testing
# Make a simple 10x8 RGB image (not square)
img_array = np.random.randint(0, 256, (8, 10, 3), dtype=np.uint8)
pil_img = Image.fromarray(img_array, mode='RGB')
ARGS = {
'im': pil_img,
'color': (0, 0, 0)
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 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
|
| project_2d_to_6d |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/keypoint_matching.py code served (permissive licence) · get_code("b714e26e08416dae") 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 ndarray, ndim 2, dtype family float, shape (6, 6) 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 numpy as np
# Create a small 2D array with shape (N, 2)
N = 3
X = np.array([
[1.0, 2.0],
[3.0, 4.0],
[5.0, 6.0]
], dtype=np.float32)
ARGS = {
"X": X
}
- 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 ndarray, ndim 2, dtype family float, shape (6, 6) — shape (6, 6) 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
|
| project_6d_to_2d |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/keypoint_matching.py code served (permissive licence) · get_code("d33463ccd2e455f2") 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 ndarray, ndim 2, dtype family float, shape (3, 2) 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 numpy as np
# Construct a valid Z array with shape (2N, 6)
# where even rows contain X coordinates in columns 0:2
# and odd rows contain the same X coordinates in columns 2:4
N = 3
Z = np.zeros((2 * N, 6))
# Set even rows (indices 0, 2, 4) with X values in columns 0:2
Z[0, 0:2] = [1.0, 2.0]
Z[2, 0:2] = [3.0, 4.0]
Z[4, 0:2] = [5.0, 6.0]
# Set odd rows (indices 1, 3, 5) with same X values in columns 2:4
Z[1, 2:4] = [1.0, 2.0]
Z[3, 2:4] = [3.0, 4.0]
Z[5, 2:4] = [5.0, 6.0]
# Fill remaining columns with arbitrary values (not used by the function)
Z[:, 4:6] = 0.0
ARGS = {
"Z": Z
}
- 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 ndarray, ndim 2, dtype family float, shape (3, 2) — shape (3, 2) 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
|
| read_html_file |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/demo/util.py code served (permissive licence) · get_code("af4b98b7641b70f2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
import os
# Create a temporary HTML file
temp_dir = tempfile.mkdtemp()
html_file_path = os.path.join(temp_dir, "test.html")
html_content = """<!DOCTYPE html>
<html>
<head>
<title>Test Page</title>
</head>
<body>
<h1>Hello World</h1>
<p>This is a test HTML file.</p>
</body>
</html>"""
with open(html_file_path, 'w') as f:
f.write(html_content)
ARGS = {
"file": html_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 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
|
| recursive_attr |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/sound_of_water/audio_pitch/model.py code served (permissive licence) · get_code("40aef86f184e81f7") 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 Linear. 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)
# Build a nested module structure to test recursive attribute access
class SubModule(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
self.value = 42
class NestedModule(nn.Module):
def __init__(self):
super().__init__()
self.sub = SubModule()
self.param = nn.Parameter(torch.randn(2, 4))
class MainModule(nn.Module):
def __init__(self):
super().__init__()
self.nested = NestedModule()
self.tensor = torch.randn(2, 4)
# Instantiate the module
module = MainModule()
# Test cases for recursive_attr:
# 1. Simple attribute: "nested" -> returns NestedModule instance
# 2. Nested attribute: "nested.sub" -> returns SubModule instance
# 3. Deeply nested attribute: "nested.sub.linear" -> returns Linear layer
# 4. Deeply nested value: "nested.sub.value" -> returns 42
# 5. Tensor attribute: "tensor" -> returns tensor
ARGS = {
"module": module,
"attr": "nested.sub.linear"
}
- 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 Linear — a Linear output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Linear 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
|
| timestamp_to_seconds |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/epic.py code served (permissive licence) · get_code("6a7ab8acfa1aad95") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import datetime
def timestamp_to_seconds(timestamp: str):
time_obj = datetime.datetime.strptime(timestamp, '%H:%M:%S.%f')
total_seconds = time_obj.time().second + time_obj.time().minute * 60 + time_obj.time().hour * 3600 + time_obj.time().microsecond / 1000000
return total_seconds
ARGS = {
"timestamp": "12:34:56.123456"
}
- 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 float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| to_local_average_cents |
Ran ran, violated the contract we drafted |
marl/crepe/crepe/core.py code served (permissive licence) · get_code("78fc7cf6c4993dc2") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned float64, 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 numpy as np
# Test case 1: 1D salience array
salience_1d = np.array([0.1, 0.2, 0.5, 0.3, 0.2, 0.1, 0.05, 0.15, 0.25, 0.35])
# Test case 2: 2D salience array
salience_2d = np.array([
[0.1, 0.2, 0.5, 0.3, 0.2, 0.1, 0.05, 0.15, 0.25, 0.35],
[0.05, 0.15, 0.3, 0.4, 0.25, 0.2, 0.1, 0.05, 0.15, 0.2]
])
ARGS = {
"salience": salience_1d,
"center": None
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float64, 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
|
| tqdm_iterator |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/log.py code served (permissive licence) · get_code("fcc214ee70fe8c3c") 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 tqdm_asyncio. 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
from tqdm.auto import tqdm
torch.manual_seed(0)
# Simple list of items to iterate over
items = [1, 2, 3, 4, 5]
# Description for the progress bar
desc = "Processing items"
# Bar format string for customizing the progress bar appearance
bar_format = "{l_bar}{bar}{r_bar}"
# Additional kwargs that tqdm accepts
additional_kwargs = {
"total": 5,
"leave": True,
"disable": False,
}
ARGS = {
"items": items,
"desc": desc,
"bar_format": bar_format,
**additional_kwargs
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tqdm_asyncio — a tqdm_asyncio output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a tqdm_asyncio 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
|
| warp |
Ran ran on a synthesized input |
bpiyush/SoundOfWater/shared/utils/keypoint_matching.py code served (permissive licence) · get_code("422a90cfab67fc09") 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 ndarray, ndim 2, dtype family float, shape (4, 5) 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 numpy as np
# Create a small test image
im = np.array([
[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0],
[7.0, 8.0, 9.0]
], dtype=np.float32)
# Create a transformation matrix M
# The function expects M to be applied as: [u, v] = [[i, j, 0, 0, 1, 0], [0, 0, i, j, 0, 1]] @ M
# M should be a 6-element vector or 6x1 array for the matrix multiplication to work
M = np.array([1.0, 0.0, 0.0, 1.0, 0.0, 0.0], dtype=np.float32)
# Output shape
output_shape = (4, 5)
ARGS = {
"im": im,
"M": M,
"output_shape": output_shape
}
- 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 ndarray, ndim 2, dtype family float, shape (4, 5) — shape (4, 5) 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
|
| check_audio |
Not yet run unverified (harvested, no recorded run) |
bpiyush/SoundOfWater/shared/utils/misc.py code served (permissive licence) · get_code("05cc638a791e3258") How it ran |
| compute_spec_freq_mean |
Not yet run unverified (harvested, no recorded run) |
bpiyush/SoundOfWater/shared/utils/audio.py code served (permissive licence) · get_code("6c49fe145f92059d") How it ran |
| download_youtube_video |
Not yet run unverified (harvested, no recorded run) |
bpiyush/SoundOfWater/shared/utils/misc.py code served (permissive licence) · get_code("429cb9cff7a4aec9") How it ran |