def test_parent_dataset_links(some_interdeps):
"""
Test that we can set links and retrieve them when loading the dataset
"""
links = generate_some_links(3)
ds = DataSet()
for link in links:
link.head = ds.guid
ds.set_interdependencies(some_interdeps[1])
ds.parent_dataset_links = links[:2]
# setting it again/overwriting it should be okay
ds.parent_dataset_links = links
ds.mark_started()
match = re.escape('Can not set parent dataset links on a dataset '
'that has been started.')
with pytest.raises(RuntimeError, match=match):
ds.parent_dataset_links = links
ds.add_results([{'ps1': 1, 'ps2': 2}])
run_id = ds.run_id
ds_loaded = DataSet(run_id=run_id)
assert ds_loaded.parent_dataset_links == links
def test_load_by_guid(some_interdeps):
ds = DataSet()
ds.set_interdependencies(some_interdeps[1])
ds.mark_started()
ds.add_results([{'ps1': 1, 'ps2': 2}])
loaded_ds = load_by_guid(ds.guid)
assert loaded_ds.the_same_dataset_as(ds)
def test_runs_from_different_experiments_raises(two_empty_temp_db_connections,
some_interdeps):
"""
Test that inserting runs from multiple experiments raises
"""
source_conn, target_conn = two_empty_temp_db_connections
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
source_exp_1 = Experiment(conn=source_conn)
source_exp_2 = Experiment(conn=source_conn)
# make 5 runs in first experiment
exp_1_run_ids = []
for _ in range(5):
source_dataset = DataSet(conn=source_conn, exp_id=source_exp_1.exp_id)
exp_1_run_ids.append(source_dataset.run_id)
source_dataset.set_interdependencies(some_interdeps[1])
source_dataset.mark_started()
for val in range(10):
source_dataset.add_results(
[{name: val
for name in some_interdeps[1].names}])
source_dataset.mark_completed()
# make 5 runs in second experiment
exp_2_run_ids = []
for _ in range(5):
source_dataset = DataSet(conn=source_conn, exp_id=source_exp_2.exp_id)
exp_2_run_ids.append(source_dataset.run_id)
source_dataset.set_interdependencies(some_interdeps[1])
source_dataset.mark_started()
for val in range(10):
source_dataset.add_results(
[{name: val
for name in some_interdeps[1].names}])
source_dataset.mark_completed()
run_ids = exp_1_run_ids + exp_2_run_ids
source_exp_ids = np.unique([1, 2])
matchstring = ('Did not receive runs from a single experiment\\. '
f'Got runs from experiments {source_exp_ids}')
# make the matchstring safe to use as a regexp
matchstring = matchstring.replace('[', '\\[').replace(']', '\\]')
with pytest.raises(ValueError, match=matchstring):
extract_runs_into_db(source_path, target_path, *run_ids)
def test_the_same_dataset_as(some_interdeps, experiment):
ds = DataSet()
ds.set_interdependencies(some_interdeps[1])
ds.mark_started()
ds.add_results([{'ps1': 1, 'ps2': 2}])
same_ds_from_load = DataSet(run_id=ds.run_id)
assert ds.the_same_dataset_as(same_ds_from_load)
new_ds = DataSet()
assert not ds.the_same_dataset_as(new_ds)
def test_old_versions_not_touched(two_empty_temp_db_connections,
some_interdeps):
source_conn, target_conn = two_empty_temp_db_connections
target_path = path_to_dbfile(target_conn)
source_path = path_to_dbfile(source_conn)
_, new_v = get_db_version_and_newest_available_version(source_path)
fixturepath = os.sep.join(qcodes.tests.dataset.__file__.split(os.sep)[:-1])
fixturepath = os.path.join(fixturepath,
'fixtures', 'db_files', 'version2',
'some_runs.db')
if not os.path.exists(fixturepath):
pytest.skip("No db-file fixtures found. You can generate test db-files"
" using the scripts in the legacy_DB_generation folder")
# First test that we cannot use an old version as source
with raise_if_file_changed(fixturepath):
with pytest.warns(UserWarning) as warning:
extract_runs_into_db(fixturepath, target_path, 1)
expected_mssg = ('Source DB version is 2, but this '
f'function needs it to be in version {new_v}. '
'Run this function again with '
'upgrade_source_db=True to auto-upgrade '
'the source DB file.')
assert warning[0].message.args[0] == expected_mssg
# Then test that we cannot use an old version as target
# first create a run in the new version source
source_exp = Experiment(conn=source_conn)
source_ds = DataSet(conn=source_conn, exp_id=source_exp.exp_id)
source_ds.set_interdependencies(some_interdeps[1])
source_ds.mark_started()
source_ds.add_results([{name: 0.0
for name in some_interdeps[1].names}])
source_ds.mark_completed()
with raise_if_file_changed(fixturepath):
with pytest.warns(UserWarning) as warning:
extract_runs_into_db(source_path, fixturepath, 1)
expected_mssg = ('Target DB version is 2, but this '
f'function needs it to be in version {new_v}. '
'Run this function again with '
'upgrade_target_db=True to auto-upgrade '
'the target DB file.')
assert warning[0].message.args[0] == expected_mssg
def test_experiments_with_NULL_sample_name(two_empty_temp_db_connections,
some_interdeps):
"""
In older API versions (corresponding to DB version 3),
users could get away with setting the sample name to None
This test checks that such an experiment gets correctly recognised and
is thus not ever re-inserted into the target DB
"""
source_conn, target_conn = two_empty_temp_db_connections
source_exp_1 = Experiment(conn=source_conn, name='null_sample_name')
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
# make 5 runs in experiment
exp_1_run_ids = []
for _ in range(5):
source_dataset = DataSet(conn=source_conn, exp_id=source_exp_1.exp_id)
exp_1_run_ids.append(source_dataset.run_id)
source_dataset.set_interdependencies(some_interdeps[1])
source_dataset.mark_started()
for val in range(10):
source_dataset.add_results(
[{name: val
for name in some_interdeps[1].names}])
source_dataset.mark_completed()
sql = """
UPDATE experiments
SET sample_name = NULL
WHERE exp_id = 1
"""
source_conn.execute(sql)
source_conn.commit()
assert source_exp_1.sample_name is None
extract_runs_into_db(source_path, target_path, 1, 2, 3, 4, 5)
assert len(get_experiments(target_conn)) == 1
extract_runs_into_db(source_path, target_path, 1, 2, 3, 4, 5)
assert len(get_experiments(target_conn)) == 1
assert len(Experiment(exp_id=1, conn=target_conn)) == 5
def test_dataset_length():
path_to_db = get_DB_location()
ds = DataSet(path_to_db, run_id=None)
assert len(ds) == 0
parameter = ParamSpecBase(name='single', paramtype='numeric',
label='', unit='N/A')
idps = InterDependencies_(standalones=(parameter,))
ds.set_interdependencies(idps)
ds.mark_started()
ds.add_results([{parameter.name: 1}])
ds.mark_completed()
assert len(ds) == 1
def test_column_mismatch(two_empty_temp_db_connections, some_interdeps, inst):
"""
Test insertion of runs with no metadata and no snapshot into a DB already
containing a run that has both
"""
source_conn, target_conn = two_empty_temp_db_connections
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
target_exp = Experiment(conn=target_conn)
# Set up measurement scenario
station = Station(inst)
meas = Measurement(exp=target_exp, station=station)
meas.register_parameter(inst.back)
meas.register_parameter(inst.plunger)
meas.register_parameter(inst.cutter, setpoints=(inst.back, inst.plunger))
with meas.run() as datasaver:
for back_v in [1, 2, 3]:
for plung_v in [-3, -2.5, 0]:
datasaver.add_result((inst.back, back_v),
(inst.plunger, plung_v),
(inst.cutter, back_v+plung_v))
datasaver.dataset.add_metadata('meta_tag', 'meta_value')
Experiment(conn=source_conn)
source_ds = DataSet(conn=source_conn)
source_ds.set_interdependencies(some_interdeps[1])
source_ds.mark_started()
source_ds.add_results([{name: 2.1
for name in some_interdeps[1].names}])
source_ds.mark_completed()
extract_runs_into_db(source_path, target_path, 1)
# compare
target_copied_ds = DataSet(conn=target_conn, run_id=2)
assert target_copied_ds.the_same_dataset_as(source_ds)
def test_missing_runs_raises(two_empty_temp_db_connections, some_interdeps):
"""
Test that an error is raised if we attempt to extract a run not present in
the source DB
"""
source_conn, target_conn = two_empty_temp_db_connections
source_exp_1 = Experiment(conn=source_conn)
# make 5 runs in first experiment
exp_1_run_ids = []
for _ in range(5):
source_dataset = DataSet(conn=source_conn, exp_id=source_exp_1.exp_id)
exp_1_run_ids.append(source_dataset.run_id)
source_dataset.set_interdependencies(some_interdeps[1])
source_dataset.mark_started()
for val in range(10):
source_dataset.add_results(
[{name: val
for name in some_interdeps[1].names}])
source_dataset.mark_completed()
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
run_ids = [1, 8, 5, 3, 2, 4, 4, 4, 7, 8]
wrong_ids = [8, 7, 8]
expected_err = ("Error: not all run_ids exist in the source database. "
"The following run(s) is/are not present: "
f"{wrong_ids}")
with pytest.raises(ValueError, match=re.escape(expected_err)):
extract_runs_into_db(source_path, target_path, *run_ids)
def test_result_table_naming_and_run_id(two_empty_temp_db_connections,
some_interdeps):
"""
Check that a correct result table name is given and that a correct run_id
is assigned
"""
source_conn, target_conn = two_empty_temp_db_connections
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
source_exp1 = Experiment(conn=source_conn)
source_ds_1_1 = DataSet(conn=source_conn, exp_id=source_exp1.exp_id)
source_ds_1_1.set_interdependencies(some_interdeps[1])
source_ds_1_1.mark_started()
source_ds_1_1.add_results([{name: 0.0
for name in some_interdeps[1].names}])
source_ds_1_1.mark_completed()
source_exp2 = Experiment(conn=source_conn)
source_ds_2_1 = DataSet(conn=source_conn, exp_id=source_exp2.exp_id)
source_ds_2_1.set_interdependencies(some_interdeps[1])
source_ds_2_1.mark_started()
source_ds_2_1.add_results([{name: 0.0
for name in some_interdeps[1].names}])
source_ds_2_1.mark_completed()
source_ds_2_2 = DataSet(conn=source_conn,
exp_id=source_exp2.exp_id,
name="customname")
source_ds_2_2.set_interdependencies(some_interdeps[1])
source_ds_2_2.mark_started()
source_ds_2_2.add_results([{name: 0.0
for name in some_interdeps[1].names}])
source_ds_2_2.mark_completed()
extract_runs_into_db(source_path, target_path, source_ds_2_2.run_id)
# The target ds ought to have a runs table "results-1-1"
# and ought to be the same dataset as its "ancestor"
target_ds = DataSet(conn=target_conn, run_id=1)
assert target_ds.name == "customname"
assert target_ds.table_name == "results-1-1"
assert target_ds.the_same_dataset_as(source_ds_2_2)
def test_dataset_states():
"""
Test the interplay between pristine, started, running, and completed
"""
ds = DataSet()
assert ds.pristine is True
assert ds.running is False
assert ds.started is False
assert ds.completed is False
with pytest.raises(RuntimeError, match='Can not mark DataSet as complete '
'before it has '
'been marked as started.'):
ds.mark_completed()
match = ('This DataSet has not been marked as started. '
'Please mark the DataSet as started before '
'adding results to it.')
with pytest.raises(RuntimeError, match=match):
ds.add_results([{'x': 1}])
parameter = ParamSpecBase(name='single', paramtype='numeric',
label='', unit='N/A')
idps = InterDependencies_(standalones=(parameter,))
ds.set_interdependencies(idps)
ds.mark_started()
assert ds.pristine is False
assert ds.running is True
assert ds.started is True
assert ds.completed is False
match = ('Can not set interdependencies on a DataSet that has '
'been started.')
with pytest.raises(RuntimeError, match=match):
ds.set_interdependencies(idps)
ds.add_results([{parameter.name: 1}])
ds.mark_completed()
assert ds.pristine is False
assert ds.running is False
assert ds.started is True
assert ds.completed is True
match = ('Can not set interdependencies on a DataSet that has '
'been started.')
with pytest.raises(RuntimeError, match=match):
ds.set_interdependencies(idps)
match = ('This DataSet is complete, no further '
'results can be added to it.')
with pytest.raises(CompletedError, match=match):
ds.add_results([{parameter.name: 1}])
def create_ds_with_exp_id(exp_id):
ds = DataSet(exp_id=exp_id)
ds.set_interdependencies(some_interdeps[1])
ds.mark_started()
ds.add_results([{'ps1': 1, 'ps2': 2}])
return ds
def test_correct_experiment_routing(two_empty_temp_db_connections,
some_interdeps):
"""
Test that existing experiments are correctly identified AND that multiple
insertions of the same runs don't matter (run insertion is idempotent)
"""
source_conn, target_conn = two_empty_temp_db_connections
source_exp_1 = Experiment(conn=source_conn)
# make 5 runs in first experiment
exp_1_run_ids = []
for _ in range(5):
source_dataset = DataSet(conn=source_conn, exp_id=source_exp_1.exp_id)
exp_1_run_ids.append(source_dataset.run_id)
source_dataset.set_interdependencies(some_interdeps[1])
source_dataset.mark_started()
for val in range(10):
source_dataset.add_results(
[{name: val
for name in some_interdeps[1].names}])
source_dataset.mark_completed()
# make a new experiment with 1 run
source_exp_2 = Experiment(conn=source_conn)
ds = DataSet(conn=source_conn, exp_id=source_exp_2.exp_id, name="lala")
exp_2_run_ids = [ds.run_id]
ds.set_interdependencies(some_interdeps[1])
ds.mark_started()
for val in range(10):
ds.add_results([{name: val for name in some_interdeps[1].names}])
ds.mark_completed()
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
# now copy 2 runs
extract_runs_into_db(source_path, target_path, *exp_1_run_ids[:2])
target_exp1 = Experiment(conn=target_conn, exp_id=1)
assert len(target_exp1) == 2
# copy two other runs, one of them already in
extract_runs_into_db(source_path, target_path, *exp_1_run_ids[1:3])
assert len(target_exp1) == 3
# insert run from different experiment
extract_runs_into_db(source_path, target_path, ds.run_id)
assert len(target_exp1) == 3
target_exp2 = Experiment(conn=target_conn, exp_id=2)
assert len(target_exp2) == 1
# finally insert every single run from experiment 1
extract_runs_into_db(source_path, target_path, *exp_1_run_ids)
# check for idempotency once more by inserting all the runs but in another
# order
with raise_if_file_changed(target_path):
extract_runs_into_db(source_path, target_path, *exp_1_run_ids[::-1])
target_exps = get_experiments(target_conn)
assert len(target_exps) == 2
assert len(target_exp1) == 5
assert len(target_exp2) == 1
# check that all the datasets match up
for run_id in exp_1_run_ids + exp_2_run_ids:
source_ds = DataSet(conn=source_conn, run_id=run_id)
target_ds = load_by_guid(guid=source_ds.guid, conn=target_conn)
assert source_ds.the_same_dataset_as(target_ds)
source_data = source_ds.get_parameter_data(
*source_ds.parameters.split(','))
target_data = target_ds.get_parameter_data(
*target_ds.parameters.split(','))
for outkey, outval in source_data.items():
for inkey, inval in outval.items():
np.testing.assert_array_equal(inval,
target_data[outkey][inkey])
def test_basic_extraction(two_empty_temp_db_connections, some_interdeps):
source_conn, target_conn = two_empty_temp_db_connections
source_path = path_to_dbfile(source_conn)
target_path = path_to_dbfile(target_conn)
type_casters = {
'numeric':
float,
'array': (lambda x: np.array(x)
if hasattr(x, '__iter__') else np.array([x])),
'text':
str
}
source_exp = Experiment(conn=source_conn)
source_dataset = DataSet(conn=source_conn, name="basic_copy_paste_name")
with pytest.raises(RuntimeError) as excinfo:
extract_runs_into_db(source_path, target_path, source_dataset.run_id)
assert error_caused_by(excinfo, ('Dataset not completed. An incomplete '
'dataset can not be copied. The '
'incomplete dataset has GUID: '
f'{source_dataset.guid} and run_id: '
f'{source_dataset.run_id}'))
source_dataset.set_interdependencies(some_interdeps[0])
source_dataset.parent_dataset_links = [
Link(head=source_dataset.guid,
tail=str(uuid.uuid4()),
edge_type='test_link')
]
source_dataset.mark_started()
for value in range(10):
result = {
ps.name: type_casters[ps.type](value)
for ps in some_interdeps[0].paramspecs
}
source_dataset.add_results([result])
source_dataset.add_metadata('goodness', 'fair')
source_dataset.add_metadata('test', True)
source_dataset.mark_completed()
assert source_dataset.run_id == source_dataset.captured_run_id
extract_runs_into_db(source_path, target_path, source_dataset.run_id)
target_exp = Experiment(conn=target_conn, exp_id=1)
length1 = len(target_exp)
assert length1 == 1
# trying to insert the same run again should be a NOOP
with raise_if_file_changed(target_path):
extract_runs_into_db(source_path, target_path, source_dataset.run_id)
assert len(target_exp) == length1
target_dataset = DataSet(conn=target_conn, run_id=1)
# Now make the interesting comparisons: are the target objects the same as
# the source objects?
assert source_dataset.the_same_dataset_as(target_dataset)
source_data = source_dataset.get_parameter_data(
*source_dataset.parameters.split(','))
target_data = target_dataset.get_parameter_data(
*target_dataset.parameters.split(','))
for outkey, outval in source_data.items():
for inkey, inval in outval.items():
np.testing.assert_array_equal(inval, target_data[outkey][inkey])
exp_attrs = [
'name', 'sample_name', 'format_string', 'started_at', 'finished_at'
]
for exp_attr in exp_attrs:
assert getattr(source_exp, exp_attr) == getattr(target_exp, exp_attr)
# trying to insert the same run again should be a NOOP
with raise_if_file_changed(target_path):
extract_runs_into_db(source_path, target_path, source_dataset.run_id)
