| align_gt_to_test_order |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/common/gt_alignment.py code served (permissive licence) · get_code("011a5646655b348d") 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 numpy as np
# Create small valid test data
# 4 points in 3D space
np.random.seed(0)
test_xyz = np.random.randn(4, 3).astype(np.float64)
gt_xyz = test_xyz.copy() + np.random.randn(4, 3) * 1e-7 # Near-identical with tiny perturbation
gt_labels = np.array([0, 1, 1, 0], dtype=np.uint8) # Binary labels with at least one positive
ARGS = {
'test_xyz': test_xyz,
'gt_xyz': gt_xyz,
'gt_labels': gt_labels,
'tolerance': 1e-5,
'n_jobs': 1,
'require_positive': True,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy, sklearn — 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
|
| anomaly_shapenet_resolution |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/common/plan_schema.py code served (permissive licence) · get_code("135ced43d7159bd2") 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 math
from typing import Any, Dict, Iterable, List, Mapping, Sequence, Tuple
# Construct valid arguments for anomaly_shapenet_resolution
train_point_counts = [100, 200, 150]
ARGS = {
'train_point_counts': train_point_counts
}
- 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
|
| audit_sample |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/common/audit_core.py code served (permissive licence) · get_code("3f318d1063f508bf") 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 numpy as np
from pathlib import Path
import tempfile
import json
# Create a temporary directory for test files
temp_dir = tempfile.mkdtemp()
temp_path = Path(temp_dir)
# Create minimal test files
test_input_file = temp_path / "test_input.pcd"
test_input_file.write_text("# .PCD v.7 - Point Cloud Data file format\nVERSION .7\nFIELDS x y z\nSIZE 4 4 4\nTYPE f f f\nCOUNT 1 1 1\nWIDTH 2\nHEIGHT 1\nVIEWPOINT 0 0 0 1 0 0 0\nPOINTS 2\nDATA ascii\n0.0 0.0 0.0\n1.0 1.0 1.0\n")
gt_projected_file = temp_path / "gt_projected.npy"
np.save(gt_projected_file, np.array([1, 1], dtype=np.int64))
fps_indices_file = temp_path / "fps_indices.npy"
np.save(fps_indices_file, np.array([0, 1], dtype=np.int64))
source_index_file = temp_path / "source_index.npy"
np.save(source_index_file, np.array([0, 1], dtype=np.int64))
is_input_point_file = temp_path / "is_input_point.npy"
np.save(is_input_point_file, np.array([1, 1], dtype=np.int64))
round_id_file = temp_path / "round_id.npy"
np.save(round_id_file, np.array([0, 0], dtype=np.int64))
metadata_file = temp_path / "metadata.json"
metadata = {
"dataset": "test_dataset",
"subset": "test",
"class_name": "test_class",
"sample_name": "test_sample",
"original_points": 2,
"input_points": 2,
"output_target_points": 2,
"generation_rounds": 1,
"gt_positive_count": 2
}
with open(metadata_file, 'w') as f:
json.dump(metadata, f)
# Create a mock row dictionary
row = {
'dataset': 'test_dataset',
'subset': 'test',
'class_name': 'test_class',
'sample_name': 'test_sample',
'original_points': 2,
'input_points': 2,
'output_target_points': 2,
'generation_rounds': 1,
'test_input_path': str(test_input_file),
'gt_projected_path': str(gt_projected_file),
'fps_indices_path': str(fps_indices_file),
'source_index_path': str(source_index_file),
'is_input_point_path': str(is_input_point_file),
'round_id_path': str(round_id_file),
'metadata_path': str(metadata_file),
'source_test_path': str(test_input_file),
'source_gt_path': '',
'sample_type': 'normal',
'gt_format': 'comma_xyz_label',
'gt_match_tolerance': 0.1
}
# Create recomputed_fps_indices as optional parameter
recomputed_fps_indices = np.array([0, 1], dtype=np.int64)
ARGS = {
'row': row,
'recomputed_fps_indices': recomputed_fps_indices
}
- 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 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
|
| augment_batch |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
gyutong406-commits/PC2-AD/approach/train/contrastive_normality/contrastive_core.py code served (permissive licence) · get_code("8dc4d570e3d816db") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (2, 4, 3) 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 argparse
import torch
import math
torch.manual_seed(0)
# Create a small batch of point cloud data: [batch_size=2, num_points=4, coords=3]
points = torch.randn(2, 4, 3, dtype=torch.float32)
# Create argparse.Namespace with all required arguments
args = argparse.Namespace(
rotate_z=True,
scale_min=0.8,
scale_max=1.2,
jitter_std=0.01,
jitter_clip=0.05,
dropout_max=0.2
)
ARGS = {
"points": points,
"args": args
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (2, 4, 3) — shape (2, 4, 3) 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
|
| build_morton_blocks |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
gyutong406-commits/PC2-AD/approach/data_preparation/common/fps_sampling.py code served (permissive licence) · get_code("5021029aef1d8f78") 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 numpy as np
# Create small test data
np.random.seed(0)
# Generate 7 random 3D points in the range [0, 10]
points = np.random.uniform(0, 10, size=(7, 3)).astype(np.float64)
# Set parameters
block_size = 3
bits = 8
# Build ARGS dict with all parameters for build_morton_blocks
ARGS = {
"points": points,
"block_size": block_size,
"bits": bits,
}
- 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 — 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
|
| build_plan_rows |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/anomaly_shapenet/build_plan.py code served (permissive licence) · get_code("baf2acbb57d1fef3") 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
from pathlib import Path
from unittest.mock import MagicMock, patch
# Create temporary directories for the test structure
temp_dir = tempfile.TemporaryDirectory()
dataset_root = Path(temp_dir.name) / "dataset"
output_root = Path(temp_dir.name) / "output"
dataset_root.mkdir(parents=True, exist_ok=True)
output_root.mkdir(parents=True, exist_ok=True)
# Create a mock class structure with required directories and files
class_dir = dataset_root / "test_class"
class_dir.mkdir(parents=True, exist_ok=True)
train_dir = class_dir / "train"
train_dir.mkdir(parents=True, exist_ok=True)
test_dir = class_dir / "test"
test_dir.mkdir(parents=True, exist_ok=True)
gt_dir = class_dir / "GT"
gt_dir.mkdir(parents=True, exist_ok=True)
# Create dummy PCD files
train_file = train_dir / "train_sample.pcd"
train_file.write_text("# dummy pcd\n")
test_file = test_dir / "test_positive.pcd"
test_file.write_text("# dummy pcd\n")
gt_file = gt_dir / "test_positive.txt"
gt_file.write_text("0,0,0,0\n")
# Mock the helper functions that are called but not defined in the snippet
def mock_read_pcd_point_count(path):
return 1000
def mock_anomaly_shapenet_resolution(train_counts):
return {
'train_sample_count': len(train_counts),
'train_point_sum': sum(train_counts),
'train_mean_points': sum(train_counts) // len(train_counts) if train_counts else 0,
'input_points': 2048,
'input_rule': 'farthest_point_sample',
'output_target_points': 2048,
'output_rule': 'farthest_point_sample',
'generation_rounds': 1,
}
def mock_validate_plan_rows(rows, require_source_files=True):
return rows
PLAN_VERSION = 1
# Patch the global functions
import sys
current_module = sys.modules[__name__]
current_module.read_pcd_point_count = mock_read_pcd_point_count
current_module.anomaly_shapenet_resolution = mock_anomaly_shapenet_resolution
current_module.validate_plan_rows = mock_validate_plan_rows
current_module.PLAN_VERSION = PLAN_VERSION
ARGS = {
'dataset_root': dataset_root,
'output_root': output_root,
'subset': 'pcd',
'fps_seed': 42,
'fps_block_size': 4096,
'fps_batch_size': 16,
'morton_bits': 21,
'gt_match_tolerance': 1e-06,
}
- 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
|
| build_state_arrays |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
gyutong406-commits/PC2-AD/approach/data_preparation/common/output_writer.py code served (permissive licence) · get_code("46807b270ff8372c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a simple 1D array of indices for fps_indices
fps_indices = np.array([0, 5, 10, 15, 20], dtype=np.int64)
ARGS = {
'fps_indices': fps_indices
}
- 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 tuple, ndim 2, dtype family int — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| check_equal |
Ran ran, violated the contract we drafted |
gyutong406-commits/PC2-AD/environments/gradpu118fix/verify.py code served (permissive licence) · get_code("a62fb7b850f2bdd8") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
ARGS = {
'name': 'test_equality_check',
'actual': 'hello world',
'expected': 'hello world'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| contains_forbidden_public_token |
Ran ran, violated the contract we drafted |
gyutong406-commits/PC2-AD/approach/data_preparation/common/plan_schema.py code served (permissive licence) · get_code("25924b38d2bca762") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
ARGS = {
"value": "test1"
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| contrastive_loss_and_metrics |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/train/contrastive_normality/contrastive_core.py code served (permissive licence) · get_code("cb133a02450c2bf7") 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
import torch.nn.functional as F
torch.manual_seed(0)
# Create small tensors for z1_raw and z2_raw
# The function expects:
# - z1_raw and z2_raw to have the same shape
# - batch size >= 2
# - They are normalized and used in matmul operations
# Using batch size 2, feature dimension 4
batch_size = 2
feature_dim = 4
z1_raw = torch.randn(batch_size, feature_dim)
z2_raw = torch.randn(batch_size, feature_dim)
temperature = 0.07
ARGS = {
'z1_raw': z1_raw,
'z2_raw': z2_raw,
'temperature': temperature,
}
- 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
|
| decode_h5_string |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/train/contrastive_normality/contrastive_core.py code served (permissive licence) · get_code("809127532d86b9a4") 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)
# The function decode_h5_string takes a single parameter 'x'
# It checks if x is bytes and decodes it as UTF-8, otherwise converts to string
# We'll test with a bytes object since that's the main use case
ARGS = {
'x': b'hello world'
}
- 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
|
| is_normal_sample |
Ran ran, violated the contract we drafted |
gyutong406-commits/PC2-AD/approach/data_preparation/anomaly_shapenet/build_plan.py code served (permissive licence) · get_code("dd8f4aad21ca37dc") 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 re
def is_normal_sample(name: str) -> bool:
lower = name.lower()
return 'positive' in lower or re.search('(^|_)good(?:_|$)', lower) is not None
ARGS = {
"name": "positive_sample"
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_config |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/normality_training/build_normality_data.py code served (permissive licence) · get_code("bdd6242c037f6238") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import tempfile
from pathlib import Path
import yaml
# Create a temporary directory and a valid YAML configuration file
temp_dir = tempfile.TemporaryDirectory()
config_path = Path(temp_dir.name) / "config.yaml"
# Write a valid YAML configuration
config_data = {
"model": "test_model",
"learning_rate": 0.001,
"batch_size": 32,
"epochs": 10,
"nested": {
"key1": "value1",
"key2": 42
}
}
with config_path.open('w', encoding='utf-8') as f:
yaml.safe_dump(config_data, f)
ARGS = {
"path": config_path
}
- 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
|
| load_gt_txt |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/common/gt_alignment.py code served (permissive licence) · get_code("33ffd4e96640bc66") 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 tempfile
from pathlib import Path
import numpy as np
# Create a temporary file with valid ground truth data
with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
temp_path = f.name
# Write some sample GT data: x, y, z, label, (and optional extra columns)
f.write("1.0 2.0 3.0 1.0 5.0\n")
f.write("4.0 5.0 6.0 0.0 7.0\n")
f.write("7.0 8.0 9.0 1.0 8.0\n")
ARGS = {
'path': Path(temp_path),
'delimiter': None,
}
- 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 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_metadata |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/common/audit_core.py code served (permissive licence) · get_code("795221c9231146f1") 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
from pathlib import Path
# Create a temporary JSON file with valid metadata
temp_dir = tempfile.TemporaryDirectory()
metadata_path = Path(temp_dir.name) / "metadata.json"
# Write a valid metadata dict to the file
metadata = {
"version": "1.0",
"name": "test_metadata",
"description": "A test metadata file",
"tags": ["test", "example"],
"count": 42
}
with metadata_path.open('w', encoding='utf-8') as f:
json.dump(metadata, f)
ARGS = {
"path": metadata_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
|
| morton_codes |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
gyutong406-commits/PC2-AD/approach/data_preparation/common/fps_sampling.py code served (permissive licence) · get_code("0476e3fd59c102cb") 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 1, dtype family int, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create valid arguments for morton_codes function
# points: np.ndarray with shape [N, 3] of float64 values
# bits: int in range [1, 21]
# Create a small set of 3D points
points = np.array([
[0.1, 0.2, 0.3],
[0.5, 0.6, 0.7],
[0.9, 0.8, 0.4],
[0.2, 0.3, 0.5],
], dtype=np.float64)
bits = 10
ARGS = {
"points": points,
"bits": bits,
}
- 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 1, dtype family int, shape (4,) — shape (4,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| output_paths |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/anomaly_shapenet/build_plan.py code served (permissive licence) · get_code("349f6f1344150971") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
from pathlib import Path
import tempfile
# Create a temporary directory to use as output_root
temp_dir = tempfile.mkdtemp()
ARGS = {
'output_root': Path(temp_dir),
'subset': 'train',
'class_name': 'chair',
'stem': 'sample_001'
}
- 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_args |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/normality_training/build_normality_data.py code served (permissive licence) · get_code("3b58384c53c034e6") 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 Namespace. 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 argparse
from typing import Optional, Sequence
def parse_args(argv: Optional[Sequence[str]]=None) -> argparse.Namespace:
parser = argparse.ArgumentParser(description='Build normality-training data through one configuration-driven public entry.')
parser.add_argument('--config', type=str, required=True)
parser.add_argument('--max_samples', '--max-samples', dest='max_samples', type=int, default=0)
parser.add_argument('--max_patches_per_sample', '--max-patches-per-sample', dest='max_patches_per_sample', type=int, default=0)
parser.add_argument('--overwrite', action='store_true')
parser.add_argument('--validate_only', '--validate-only', dest='validate_only', action='store_true')
return parser.parse_args(argv)
# Setup code to construct valid arguments
ARGS = {
'argv': [
'--config', '/path/to/config.yaml',
'--max_samples', '100',
'--max_patches_per_sample', '10',
'--overwrite',
'--validate_only'
]
}
- 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 Namespace — a Namespace output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Namespace 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_config_gpu_ids |
Ran ran, honoured the contract we drafted |
gyutong406-commits/PC2-AD/approach/data_preparation/normality_training/build_normality_data.py code served (permissive licence) · get_code("cba24a83b92c41f9") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from typing import Any, Dict, List, Mapping, Optional, Sequence
torch.manual_seed(0)
# parse_config_gpu_ids takes one parameter: value
# The function checks if value is a str or list, and processes accordingly
# Valid test cases should pass a str or list of integers
ARGS = {
"value": "0,1,2" # A valid comma-separated string of GPU IDs
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family int — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| read_pcd_point_count |
Ran ran, honoured the contract we drafted |
gyutong406-commits/PC2-AD/approach/data_preparation/common/pcd_io.py code served (permissive licence) · get_code("c8a6713868d17edc") 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 tempfile
from pathlib import Path
# Create a temporary PCD file for testing
temp_dir = tempfile.TemporaryDirectory()
temp_path = Path(temp_dir.name) / "test.pcd"
# Write a minimal valid PCD file with POINTS field
pcd_content = b"""# .PCD v.7 - Point Cloud Data file format
VERSION .7
FIELDS x y z intensity
SIZE 4 4 4 4
TYPE f f f f
COUNT 1 1 1 1
WIDTH 100
HEIGHT 1
VIEWPOINT 0 0 0 1 0 0 0
POINTS 100
DATA ascii
0 0 0 0
"""
with temp_path.open('wb') as f:
f.write(pcd_content)
ARGS = {
'path': temp_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 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
|
| real3d_ad_resolution |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/common/plan_schema.py code served (permissive licence) · get_code("11363b99ceae2d1d") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Analyzing the function:
# - Takes original_points: int as parameter
# - Checks if original < 4, raises ValueError if so
# - Returns a dict with computed values based on original_points
# - No complex objects needed, just an integer
ARGS = {
'original_points': 16
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| row_output_paths |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/anomaly_shapenet/prepare.py code served (permissive licence) · get_code("89da1d0a91bf0395") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
from pathlib import Path
from typing import Any, Mapping
# Construct a minimal row dict that satisfies the function's requirements
# The function expects a Mapping with string keys pointing to path-like values
row = {
'test_input_path': '/tmp/test_input_0',
'gt_projected_path': '/tmp/gt_projected_0',
'fps_indices_path': '/tmp/fps_indices_0',
'source_index_path': '/tmp/source_index_0',
'is_input_point_path': '/tmp/is_input_point_0',
'round_id_path': '/tmp/round_id_0',
'metadata_path': '/tmp/metadata_0',
}
ARGS = {
'row': row
}
- 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 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
|
| split_by_3 |
Ran ran, violated the contract we drafted |
gyutong406-commits/PC2-AD/approach/data_preparation/common/fps_sampling.py code served (permissive licence) · get_code("3ce2f4dbf0c5aa8f") 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 1, dtype family int, shape (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 numpy array with 21-bit integer values
# The function expects values that fit in 21 bits (max value 2097151)
values = np.array([0, 1, 42, 2097151, 1234567], dtype=np.uint64)
ARGS = {
"values": values
}
- 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 1, dtype family int, shape (5,) — shape (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
|
| validate_xyz |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/approach/data_preparation/common/pcd_io.py code served (permissive licence) · get_code("11dd43439e267c4b") 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, 3) 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 valid points array with shape [N, 3] where N > 0
points = np.array([
[1.0, 2.0, 3.0],
[4.0, 5.0, 6.0],
[7.0, 8.0, 9.0],
[10.0, 11.0, 12.0]
], dtype=np.float32)
ARGS = {
'points': points,
'name': 'points'
}
- 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, 3) — shape (4, 3) 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
|
| version_of |
Ran ran; our contract draft was wrong, not the code |
gyutong406-commits/PC2-AD/environments/gradpu118fix/verify.py code served (permissive licence) · get_code("91768e9a14df8e38") 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 importlib
def version_of(module_name: str) -> str:
module = importlib.import_module(module_name)
return str(getattr(module, '__version__', 'installed'))
# The function takes a module_name string and imports it,
# then tries to get its __version__ attribute, defaulting to 'installed'
# We need to provide a valid module name that exists in the environment
ARGS = {
'module_name': 'torch'
}
- 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
|
| audit_plan |
Not yet run unverified (harvested, no recorded run) |
gyutong406-commits/PC2-AD/approach/data_preparation/anomaly_shapenet/audit.py code served (permissive licence) · get_code("b3ac13ee3f64696c") How it ran |
| build_aligned_gt |
Not yet run unverified (harvested, no recorded run) |
gyutong406-commits/PC2-AD/approach/data_preparation/common/gt_alignment.py code served (permissive licence) · get_code("9ec207cf13c2799c") How it ran |
| prepare_row |
Not yet run unverified (harvested, no recorded run) |
gyutong406-commits/PC2-AD/approach/data_preparation/anomaly_shapenet/prepare.py code served (permissive licence) · get_code("b8d7a611007ed4b3") How it ran |
| read_pcd_points |
Not yet run unverified (harvested, no recorded run) |
gyutong406-commits/PC2-AD/approach/data_preparation/common/pcd_io.py code served (permissive licence) · get_code("7f838db7f406a43e") How it ran |
| run_plan |
Not yet run unverified (harvested, no recorded run) |
gyutong406-commits/PC2-AD/approach/data_preparation/anomaly_shapenet/prepare.py code served (permissive licence) · get_code("471844260d549674") How it ran |