| cartesian_to_na |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
waller-lab/bsccm/bsccm/led_array_calibration.py code served (permissive licence) · get_code("8373e974f0848703") 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 a small list of cartesian points (x, y, z positions)
# Using 3 points with 3 coordinates each
point_list_cart = np.array([
[1.0, 2.0, 3.0],
[0.5, 1.5, 2.5],
[-1.0, 0.0, 1.0]
], dtype=np.float32)
# Define z_offset
z_offset = 8
ARGS = {
"point_list_cart": point_list_cart,
"z_offset": z_offset
}
- 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
|
| compute_pupil_support |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
waller-lab/bsccm/bsccm/phase/util.py code served (permissive licence) · get_code("eb334c50bf746628") 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 (64, 64) 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
ARGS = {
'wavelength_um': 0.532,
'NA': 0.9,
'pixel_size_object_um': 0.1,
'sensor_shape': (64, 64),
'inner_na': 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 ndarray, ndim 2, dtype family float, shape (64, 64) — shape (64, 64) 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_spectra |
Ran ran; our contract draft was wrong, not the code |
waller-lab/bsccm/bsccm/fluorescence_processing/demixing_util.py code served (permissive licence) · get_code("4fdf57fe4aafde5f") 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 numpy as np
import pandas as pd
class MockBSCCM:
def __init__(self):
# Create a surface_marker_dataframe with marked/unmarked populations
n_samples = 20
self.surface_marker_dataframe = pd.DataFrame({
'selection_example_marker1_positive_cells_batch_batch1': np.concatenate([
np.ones(5), np.zeros(15)
]),
'selection_example_marker2_positive_cells_batch_batch1': np.concatenate([
np.ones(4), np.zeros(16)
]),
'ch1': np.random.randn(n_samples),
'ch2': np.random.randn(n_samples),
'ch3': np.random.randn(n_samples),
'ch4': np.random.randn(n_samples),
})
# Create index_dataframe with batch and antibodies info
self.index_dataframe = pd.DataFrame({
'batch': ['batch1'] * n_samples,
'antibodies': ['ab1,ab2'] * n_samples,
'slide_replicate': ['rep1'] * n_samples,
}, index=range(n_samples))
def get_indices(self, batch, antibodies, slide_replicate):
# Return all indices matching the criteria
mask = (
(self.index_dataframe['batch'] == batch) &
(self.index_dataframe['antibodies'] == antibodies) &
(self.index_dataframe['slide_replicate'] == slide_replicate)
)
return np.flatnonzero(mask)
ARGS = {
'bsccm': MockBSCCM(),
'channel_names': ['ch1', 'ch2', 'ch3', 'ch4'],
'unmixed_channel_names': ['marker1_channel', 'marker2_channel'],
'single_markers': ['marker1', 'marker2'],
'batch': 'batch1',
}
- 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 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
|
| generate_wotf |
Ran ran, violated the contract we drafted |
waller-lab/bsccm/bsccm/phase/functional_dpc.py code served (permissive licence) · get_code("a48b4cd3ce6c39d6") 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 4, 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 small stand-in arrays for sources and pupil
# sources: shape (batch, height, width) - batch of 2, size 4x4
# pupil: shape (height, width) - size 4x4
sources = np.random.randn(2, 4, 4) + 1j * np.random.randn(2, 4, 4)
pupil = np.random.randn(4, 4) + 1j * np.random.randn(4, 4)
ARGS = {
"sources": sources,
"pupil": pupil,
}
- 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 4, 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
|
| get_fluor_spectrum |
Ran ran, honoured the contract we drafted |
waller-lab/bsccm/bsccm/fluorescence_processing/demixing_util.py code served (permissive licence) · get_code("763a7b2995abb11a") 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 float, 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
import pandas as pd
class MockBSCCM:
def __init__(self):
# Create a surface_marker_dataframe with fluorescence data
# 10 rows, 4 channels
n_samples = 10
n_channels = 4
# Create channel names
self.channel_names = [f"channel_{i}" for i in range(n_channels)]
# Create fluorescence data
fluor_data = np.random.rand(n_samples, n_channels) * 100
# Create a binary marker column (marked=1, unmarked=0)
marker_col = np.array([1, 1, 0, 0, 0, 1, 0, 0, 0, 1])
# Build dataframe with channels + marker column
df_dict = {ch: fluor_data[:, i] for i, ch in enumerate(self.channel_names)}
df_dict['marker_A'] = marker_col
self.surface_marker_dataframe = pd.DataFrame(df_dict)
# Create index_dataframe with metadata
index_data = {
'batch': ['batch_1'] * 6 + ['batch_2'] * 4,
'antibodies': ['antibody_X'] * 6 + ['antibody_Y'] * 4,
'slide_replicate': ['slide_1'] * 6 + ['slide_2'] * 4,
}
self.index_dataframe = pd.DataFrame(index_data, index=range(n_samples))
def get_indices(self, batch=None, antibodies=None, slide_replicate=None):
"""Filter indices by metadata"""
mask = np.ones(len(self.index_dataframe), dtype=bool)
if batch is not None:
mask &= (self.index_dataframe['batch'] == batch).values
if antibodies is not None:
mask &= (self.index_dataframe['antibodies'] == antibodies).values
if slide_replicate is not None:
mask &= (self.index_dataframe['slide_replicate'] == slide_replicate).values
return np.flatnonzero(mask)
# Create the mock object
bsccm = MockBSCCM()
name = 'marker_A'
channel_names = bsccm.channel_names
ARGS = {
'name': name,
'bsccm': bsccm,
'channel_names': channel_names,
}
- 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 ndarray, ndim 1, dtype family float, 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
|
| load_fluor_images |
Ran ran; our contract draft was wrong, not the code |
waller-lab/bsccm/bsccm/fluorescence_processing/fluor_display.py code served (permissive licence) · get_code("f36a4fcd36e4aef3") 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 4, dtype family float, shape (2, 4, 5, 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
class MockDataset:
def __init__(self):
self.channels = [
'Fluor_690-',
'Fluor_627-673',
'Fluor_585-625',
'Fluor_550-570',
'Fluor_500-550',
'Fluor_426-446'
]
self.num_images = 3
self.image_height = 4
self.image_width = 5
def read_image(self, image_index, channel):
# Return a dummy image for the given index and channel
np.random.seed(image_index * 100 + hash(channel) % 100)
return np.random.rand(self.image_height, self.image_width).astype(np.float32)
dataset = MockDataset()
indices = [0, 1]
ARGS = {
"dataset": dataset,
"indices": 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 ndarray, ndim 4, dtype family float, shape (2, 4, 5, 6) — shape (2, 4, 5, 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
|
| load_led_positions_from_json |
Ran ran; our contract draft was wrong, not the code |
waller-lab/bsccm/bsccm/led_array_calibration.py code served (permissive licence) · get_code("c3916d33a01b1c79") 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
import json
import tempfile
import os
# Create a temporary JSON file with LED position data
temp_dir = tempfile.mkdtemp()
json_file = os.path.join(temp_dir, "led_positions.json")
led_data = {
"led_list": [
{"x": 1.0, "y": 2.0, "z": 3.0},
{"x": -1.5, "y": 2.5, "z": 4.0},
{"x": 0.5, "y": -1.0, "z": 2.5},
{"x": -2.0, "y": -1.5, "z": 3.5}
]
}
with open(json_file, 'w') as f:
json.dump(led_data, f)
ARGS = {
"file_name": json_file,
"z_offset": 8
}
- 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_mixed_data_subset |
Ran ran; our contract draft was wrong, not the code |
waller-lab/bsccm/bsccm/fluorescence_processing/demixing_util.py code served (permissive licence) · get_code("b62a17809dea6166") 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
import pandas as pd
class MockBSCCM:
"""Mock class that simulates the bsccm object"""
def __init__(self):
# Create sample index dataframe with required columns
self.index_dataframe = pd.DataFrame({
'antibodies': ['cd4', 'cd4', 'cd8', 'cd8', 'autofluor', 'autofluor'],
'batch': [0, 0, 0, 0, 0, 0],
'slide_replicate': ['rep1', 'rep1', 'rep1', 'rep1', 'rep1', 'rep1']
})
# Create surface marker dataframe with a marked population
self.surface_marker_dataframe = {
'selection_example_cd4_positive_cells_batch_0': np.array([1, 0, 1, 0, 0, 0]),
'selection_example_autofluor_positive_cells_batch_0': np.array([0, 0, 0, 0, 0, 0])
}
def get_indices(self, antibodies='cd4', batch=0, slide_replicate='rep1'):
"""Return indices matching the query parameters"""
mask = (
(self.index_dataframe['antibodies'] == antibodies) &
(self.index_dataframe['batch'] == batch) &
(self.index_dataframe['slide_replicate'] == slide_replicate)
)
return np.flatnonzero(mask.values)
# Create sample mixed data (6 samples, 4 features)
mixed_data = np.random.randn(6, 4).astype(np.float32)
# Create bsccm mock object
bsccm = MockBSCCM()
# Create selections dictionary with batch keys
selections = {
0: ['selection_example_cd4_positive_cells_batch_0'],
1: []
}
# Define arguments for load_mixed_data_subset
ARGS = {
'mixed_data': mixed_data,
'antibodies': 'cd4',
'selections': selections,
'bsccm': bsccm,
'batch': 0
}
- 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 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
|
| lowess_2d |
Ran ran; our contract draft was wrong, not the code |
waller-lab/bsccm/bsccm/fluorescence_processing/shading_correction_util.py code served (permissive licence) · get_code("937c6649663d4cdf") 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 (2, 1) 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small sample data for 2D LOWESS
# y_pos: y coordinates of data points
y_pos = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
# x_pos: x coordinates of data points
x_pos = np.array([1.5, 2.5, 3.5, 4.5, 5.5])
# z_val: values at each (y, x) position
z_val = np.array([1.2, 2.3, 3.1, 4.2, 5.1])
# yx_query_points: points where we want to predict values (shape: n_queries x 2)
yx_query_points = np.array([[2.0, 2.0], [4.0, 4.0]])
# alpha: fraction of data to use in local regression
alpha = 0.6
# weight_fn: weighting function type
weight_fn = 'tricubic'
# window_sigma: standard deviation for gaussian weighting
window_sigma = 100
ARGS = {
'y_pos': y_pos,
'x_pos': x_pos,
'z_val': z_val,
'yx_query_points': yx_query_points,
'alpha': alpha,
'weight_fn': weight_fn,
'window_sigma': window_sigma
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — 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 (2, 1) — shape (2, 1) 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
|
| make_multi_channel_fluor_images |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
waller-lab/bsccm/bsccm/fluorescence_processing/fluor_display.py code served (permissive licence) · get_code("ee9531f7bb549c14") 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 3, dtype family float, shape (4, 5, 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
from matplotlib.colors import LinearSegmentedColormap
# Create a small 6-channel fluorescence image array
# Shape: (height, width, channels) = (4, 5, 6)
# Values in range [0, 255] to simulate typical fluorescence microscopy data
np.random.seed(0)
images = np.random.randint(0, 256, size=(4, 5, 6)).astype(np.float32)
ARGS = {
"images": images
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family float, shape (4, 5, 3) — shape (4, 5, 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
|
| show_image |
Ran ran; our contract draft was wrong, not the code |
waller-lab/bsccm/bsccm/creation/plot_util.py code served (permissive licence) · get_code("f17e3af3cae2563d") 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 AxesImage. 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
import numpy as np
# Create a small 2D image array with distinct dimensions for probing
image = np.random.rand(4, 3) * 100
# Create a matplotlib figure and axis
fig, ax = plt.subplots()
# Define the ARGS dictionary with all parameters
ARGS = {
'image': image,
'ax': ax,
'contrast_max': 80.0,
'contrast_min': 20.0,
'name': 'Test Image',
'colorbar': True
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type AxesImage — a AxesImage output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a AxesImage 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
|
| spatial_freq_grid |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
waller-lab/bsccm/bsccm/phase/util.py code served (permissive licence) · get_code("780b58e825f8020c") 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 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 numpy as np
# Analyze the function:
# - sensor_shape: used as np.array, indexed with [0] and [1], passed to np.mod, np.arange
# Should be a tuple or list of 2 integers (even numbers to avoid exception)
# - pixel_size_object_um: multiplied with sensor_shape array, indexed with [0] and [1]
# Should be a scalar or array-like of 2 elements
ARGS = {
"sensor_shape": (4, 6), # Even dimensions to avoid the odd pixel exception
"pixel_size_object_um": 0.5 # Scalar pixel size in micrometers
}
- 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 3, 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
|
| decimal_format_ticks |
Not yet run unverified (harvested, no recorded run) |
waller-lab/bsccm/bsccm/creation/plot_util.py code served (permissive licence) · get_code("91ebe8c928b19fcb") How it ran |
| download_dataset |
Not yet run unverified (harvested, no recorded run) |
waller-lab/bsccm/bsccm/bsccm.py code served (permissive licence) · get_code("a5a587702d4dcf7f") How it ran |
| get_led_na |
Not yet run unverified (harvested, no recorded run) |
waller-lab/bsccm/bsccm/led_array_calibration.py code served (permissive licence) · get_code("f64a8e8550d1292d") How it ran |
| zernike_polynomials |
Not yet run unverified (harvested, no recorded run) |
waller-lab/bsccm/bsccm/phase/util.py code served (permissive licence) · get_code("8c7d4ec86da93c22") How it ran |