def test_set_interdependencies(dataset):
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 1
parameter_a = ParamSpecBase("a_param", "NUMERIC")
parameter_b = ParamSpecBase("b_param", "NUMERIC")
parameter_c = ParamSpecBase("c_param", "array")
idps = InterDependencies_(
inferences={parameter_c: (parameter_a, parameter_b)})
dataset.set_interdependencies(idps)
# write the parameters to disk
dataset.mark_started()
# Now retrieve the paramspecs
shadow_ds = make_shadow_dataset(dataset)
paramspecs = shadow_ds.paramspecs
expected_keys = ['a_param', 'b_param', 'c_param']
keys = sorted(list(paramspecs.keys()))
assert keys == expected_keys
for expected_param_name in expected_keys:
ps = paramspecs[expected_param_name]
assert ps.name == expected_param_name
assert paramspecs == dataset.paramspecs
def test_add_data_array():
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 0
idps = InterDependencies_(standalones=(ParamSpecBase("x", "numeric"),
ParamSpecBase("y", "array")))
mydataset = new_data_set("test")
mydataset.set_interdependencies(idps)
mydataset.mark_started()
expected_x = []
expected_y = []
for x in range(100):
expected_x.append([x])
y = np.random.random_sample(10)
expected_y.append([y])
mydataset.add_result({"x": x, "y": y})
shadow_ds = make_shadow_dataset(mydataset)
assert mydataset.get_data('x') == expected_x
assert shadow_ds.get_data('x') == expected_x
y_data = mydataset.get_data('y')
np.testing.assert_allclose(y_data, expected_y)
y_data = shadow_ds.get_data('y')
np.testing.assert_allclose(y_data, expected_y)
def test_add_experiments(experiment_name, sample_name, dataset_name):
global n_experiments
n_experiments += 1
_ = new_experiment(experiment_name, sample_name=sample_name)
exps = experiments()
assert len(exps) == n_experiments
exp = exps[-1]
assert exp.name == experiment_name
assert exp.sample_name == sample_name
assert exp.last_counter == 0
dataset = new_data_set(dataset_name)
dsid = dataset.run_id
loaded_dataset = load_by_id(dsid)
expected_ds_counter = 1
assert loaded_dataset.name == dataset_name
assert loaded_dataset.counter == expected_ds_counter
assert loaded_dataset.table_name == "{}-{}-{}".format(
dataset_name, exp.exp_id, loaded_dataset.counter)
expected_ds_counter += 1
dataset = new_data_set(dataset_name)
dsid = dataset.run_id
loaded_dataset = load_by_id(dsid)
assert loaded_dataset.name == dataset_name
assert loaded_dataset.counter == expected_ds_counter
assert loaded_dataset.table_name == "{}-{}-{}".format(
dataset_name, exp.exp_id, loaded_dataset.counter)
def test_add_paramspec(dataset):
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 1
parameter_a = ParamSpec("a_param", "NUMERIC")
parameter_b = ParamSpec("b_param", "NUMERIC", key="value", number=1)
parameter_c = ParamSpec("c_param",
"array",
inferred_from=[parameter_a, parameter_b])
dataset.add_parameters([parameter_a, parameter_b, parameter_c])
# Now retrieve the paramspecs
paramspecs = dataset.paramspecs
expected_keys = ['a_param', 'b_param', 'c_param']
keys = sorted(list(paramspecs.keys()))
assert keys == expected_keys
for expected_param_name in expected_keys:
ps = paramspecs[expected_param_name]
assert ps.name == expected_param_name
assert paramspecs['c_param'].inferred_from == 'a_param, b_param'
def test_add_data_1d(experiment):
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 0
psx = ParamSpec("x", "numeric")
psy = ParamSpec("y", "numeric", depends_on=['x'])
mydataset = new_data_set("test-dataset", specs=[psx, psy])
expected_x = []
expected_y = []
for x in range(100):
expected_x.append([x])
y = 3 * x + 10
expected_y.append([y])
mydataset.add_result({"x": x, "y": y})
assert mydataset.get_data('x') == expected_x
assert mydataset.get_data('y') == expected_y
with pytest.raises(ValueError):
mydataset.add_result({'y': 500})
assert mydataset.completed is False
mydataset.mark_complete()
assert mydataset.completed is True
with pytest.raises(ValueError):
mydataset.add_result({'y': 500})
with pytest.raises(CompletedError):
mydataset.add_result({'x': 5})
def test_add_paramspec_one_by_one(dataset):
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 1
parameters = [
ParamSpec("a", "NUMERIC"),
ParamSpec("b", "NUMERIC", key="value", number=1),
ParamSpec("c", "array")
]
for parameter in parameters:
dataset.add_parameter(parameter)
paramspecs = dataset.paramspecs
expected_keys = ['a', 'b', 'c']
keys = sorted(list(paramspecs.keys()))
assert keys == expected_keys
for expected_param_name in expected_keys:
ps = paramspecs[expected_param_name]
assert ps.name == expected_param_name
with pytest.raises(ValueError):
dataset.add_parameter(parameters[0])
assert len(dataset.paramspecs.keys()) == 3
def test_add_data_array():
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 0
idps = InterDependencies_(standalones=(ParamSpecBase("x", "numeric"),
ParamSpecBase("y", "array")))
mydataset = new_data_set("test")
mydataset.set_interdependencies(idps)
mydataset.mark_started()
expected_x = np.arange(100)
expected_y = []
for x in range(100):
y = np.random.random_sample(10)
expected_y.append(y)
mydataset.add_results([{"x": x, "y": y}])
shadow_ds = make_shadow_dataset(mydataset)
np.testing.assert_array_equal(mydataset.get_parameter_data()['x']['x'],
np.array(expected_x))
np.testing.assert_array_equal(shadow_ds.get_parameter_data()['x']['x'],
np.array(expected_x))
y_data = mydataset.get_parameter_data()['y']['y']
np.testing.assert_allclose(y_data, expected_y)
y_data = shadow_ds.get_parameter_data()['y']['y']
np.testing.assert_allclose(y_data, expected_y)
def test_load_by_counter(dataset):
dataset = load_by_counter(1, 1)
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert dataset.name == "test-dataset"
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 1
def test_load_by_counter():
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 1
dataset = load_by_counter(1, 1)
assert "test-dataset" == dataset.name
assert exp.sample_name == dataset.sample_name
assert exp.name == dataset.exp_name
def test_add_data_1d():
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 0
psx = ParamSpecBase("x", "numeric")
psy = ParamSpecBase("y", "numeric")
idps = InterDependencies_(dependencies={psy: (psx, )})
mydataset = new_data_set("test-dataset")
mydataset.set_interdependencies(idps)
mydataset.mark_started()
expected_x = []
expected_y = []
for x in range(100):
expected_x.append(x)
y = 3 * x + 10
expected_y.append(y)
mydataset.add_results([{"x": x, "y": y}])
shadow_ds = make_shadow_dataset(mydataset)
np.testing.assert_array_equal(mydataset.get_parameter_data()['y']['x'],
expected_x)
np.testing.assert_array_equal(mydataset.get_parameter_data()['y']['y'],
expected_y)
np.testing.assert_array_equal(shadow_ds.get_parameter_data()['y']['x'],
expected_x)
np.testing.assert_array_equal(shadow_ds.get_parameter_data()['y']['y'],
expected_y)
assert mydataset.completed is False
mydataset.mark_completed()
assert mydataset.completed is True
with pytest.raises(CompletedError):
mydataset.add_results([{'y': 500}])
with pytest.raises(CompletedError):
mydataset.add_results([{'x': 5}])
def test_add_paramspec_one_by_one(dataset):
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 1
parameters = [
ParamSpec("a", "NUMERIC"),
ParamSpec("b", "NUMERIC", key="value", number=1),
ParamSpec("c", "array")
]
for parameter in parameters:
dataset.add_parameter(parameter)
# test that we can not re-add any parameter already added once
for param in parameters:
with pytest.raises(ValueError,
match=f'Duplicate parameter name: '
f'{param.name}'):
dataset.add_parameter(param)
dataset.mark_started()
shadow_ds = make_shadow_dataset(dataset)
paramspecs = shadow_ds.paramspecs
expected_keys = ['a', 'b', 'c']
keys = sorted(list(paramspecs.keys()))
assert keys == expected_keys
for expected_param_name in expected_keys:
ps = paramspecs[expected_param_name]
assert ps.name == expected_param_name
assert paramspecs == dataset.paramspecs
# Test that is not possible to add any parameter to the dataset
with pytest.raises(RuntimeError,
match='Can not add parameters to a '
'DataSet that has been started.'):
dataset.add_parameter(parameters[0])
assert len(dataset.paramspecs.keys()) == 3
assert len(shadow_ds.paramspecs.keys()) == 3
def test_add_data_1d():
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 0
psx = ParamSpecBase("x", "numeric")
psy = ParamSpecBase("y", "numeric")
idps = InterDependencies_(dependencies={psy: (psx, )})
mydataset = new_data_set("test-dataset")
mydataset.set_interdependencies(idps)
mydataset.mark_started()
expected_x = []
expected_y = []
for x in range(100):
expected_x.append([x])
y = 3 * x + 10
expected_y.append([y])
mydataset.add_result({"x": x, "y": y})
shadow_ds = make_shadow_dataset(mydataset)
assert mydataset.get_data('x') == expected_x
assert mydataset.get_data('y') == expected_y
assert shadow_ds.get_data('x') == expected_x
assert shadow_ds.get_data('y') == expected_y
with pytest.raises(ValueError):
mydataset.add_result({'y': 500})
assert mydataset.completed is False
mydataset.mark_completed()
assert mydataset.completed is True
with pytest.raises(CompletedError):
mydataset.add_result({'y': 500})
with pytest.raises(CompletedError):
mydataset.add_result({'x': 5})
def _experiment_widget(tab: Tab) -> GridspecLayout:
"""Show a `ipywidgets.GridspecLayout` with information about the
loaded experiment. The clickable buttons can perform an action in ``tab``.
"""
header_names = [
"Run ID",
"Name",
"Experiment",
"Coordinates",
"Variables",
"MSMT Time",
"Notes",
]
header = {n: button(n, "info") for n in header_names}
rows = [header]
for exp in qcodes.experiments():
tooltip = f"{exp.name}#{exp.sample_name}@{exp.path_to_db}"
for ds in exp.data_sets():
coords, variables = _get_coords_and_vars(ds)
row = {}
row["Run ID"] = text(str(ds.run_id))
row["Name"] = text(ds.name)
row["Experiment"] = button(f"#{exp.exp_id}",
"warning",
tooltip=tooltip)
row["Notes"] = editable_metadata(ds)
row["Coordinates"] = expandable_dict(coords, tab, ds)
row["Variables"] = expandable_dict(variables, tab, ds)
row["MSMT Time"] = text(ds.completed_timestamp() or "")
rows.append(row)
grid = GridspecLayout(n_rows=len(rows), n_columns=len(header_names))
empty_text = text("")
for i, row in enumerate(rows):
for j, name in enumerate(header_names):
grid[i, j] = row.get(name, empty_text)
grid.layout.grid_template_rows = "auto " * len(rows)
grid.layout.grid_template_columns = "auto " * len(header_names)
return grid
def experiments_widget(
db: Optional[str] = None,
data_sets: Optional[Sequence[DataSetProtocol]] = None,
*,
sort_by: Optional[Literal["timestamp", "run_id"]] = "run_id",
) -> VBox:
r"""Displays an interactive widget that shows the ``qcodes.experiments()``.
With the edit button in the column "Notes" one can make persistent
changes to the `~qcodes.dataset.data_set.DataSet`\s attribute
``metadata`` in the key "widget_notes".
Expanding the coordinates or variables buttons, reveals more options, such
as plotting or the ability to easily browse
the `~qcodes.dataset.data_set.DataSet`\s snapshot.
Args
db: Optionally pass a database file, if no database has been loaded.
data_sets: Sequence of `~qcodes.dataset.data_set.DataSet`s.
If datasets are explicitly provided via this argument, the ``db``
argument has no effect.
sort_by: Sort datasets in widget by either "timestamp" (newest first),
"run_id" or None (no predefined sorting).
"""
if data_sets is None:
if db is not None:
initialise_or_create_database_at(db)
data_sets = [
ds for exp in qcodes.experiments() for ds in exp.data_sets()
]
if sort_by == "run_id":
data_sets = sorted(data_sets, key=lambda ds: ds.run_id)
elif sort_by == "timestamp":
data_sets = sorted(
data_sets,
key=lambda ds: ds.run_timestamp_raw if ds.run_timestamp_raw is not None else 0,
reverse=True
)
title = HTML("<h1>QCoDeS experiments widget</h1>")
tab = create_tab(do_display=False)
grid = _experiment_widget(data_sets, tab)
return VBox([title, tab, grid])
def test_add_data_array(experiment):
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 0
mydataset = new_data_set("test", specs=[ParamSpec("x", "numeric"),
ParamSpec("y", "array")])
expected_x = []
expected_y = []
for x in range(100):
expected_x.append([x])
y = np.random.random_sample(10)
expected_y.append([y])
mydataset.add_result({"x": x, "y": y})
assert mydataset.get_data('x') == expected_x
y_data = mydataset.get_data('y')
np.testing.assert_allclose(y_data, expected_y)
def test_add_paramspec_one_by_one(dataset):
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 1
parameters = [
ParamSpec("a", "NUMERIC"),
ParamSpec("b", "NUMERIC", key="value", number=1),
ParamSpec("c", "array")
]
for parameter in parameters:
dataset.add_parameter(parameter)
shadow_ds = make_shadow_dataset(dataset)
paramspecs = shadow_ds.paramspecs
expected_keys = ['a', 'b', 'c']
keys = sorted(list(paramspecs.keys()))
assert keys == expected_keys
for expected_param_name in expected_keys:
ps = paramspecs[expected_param_name]
assert ps.name == expected_param_name
assert paramspecs == dataset.paramspecs
# Test that is not possible to add the same parameter again to the dataset
with pytest.raises(ValueError,
match=f'Duplicate parameter name: '
f'{parameters[0].name}'):
dataset.add_parameter(parameters[0])
assert len(dataset.paramspecs.keys()) == 3
assert len(shadow_ds.paramspecs.keys()) == 3
def test_add_paramspec(dataset):
exps = experiments()
assert len(exps) == 1
exp = exps[0]
assert exp.name == "test-experiment"
assert exp.sample_name == "test-sample"
assert exp.last_counter == 1
parameter_a = ParamSpec("a_param", "NUMERIC")
parameter_b = ParamSpec("b_param", "NUMERIC", key="value", number=1)
parameter_c = ParamSpec("c_param",
"array",
inferred_from=[parameter_a, parameter_b])
dataset.add_parameter(parameter_a)
dataset.add_parameter(parameter_b)
dataset.add_parameter(parameter_c)
# write the parameters to disk
dataset.mark_started()
# Now retrieve the paramspecs
shadow_ds = make_shadow_dataset(dataset)
paramspecs = shadow_ds.paramspecs
expected_keys = ['a_param', 'b_param', 'c_param']
keys = sorted(list(paramspecs.keys()))
assert keys == expected_keys
for expected_param_name in expected_keys:
ps = paramspecs[expected_param_name]
assert ps.name == expected_param_name
assert set(paramspecs['c_param'].inferred_from_) == {'a_param', 'b_param'}
assert paramspecs == dataset.paramspecs
def list_exps(self):
exps = experiments()
