def generate_dataset_table(guids: Sequence[str],
conn: Optional[ConnectionPlus] = None) -> str:
"""
Generate an ASCII art table of information about the runs attached to the
supplied guids.
Args:
guids: Sequence of one or more guids
conn: A ConnectionPlus object with a connection to the database.
Returns: ASCII art table of information about the supplied guids.
"""
from tabulate import tabulate
headers = ["captured_run_id", "captured_counter", "experiment_name",
"sample_name",
"sample_id", "location", "work_station"]
table = []
for guid in guids:
ds = load_by_guid(guid, conn=conn)
parsed_guid = parse_guid(guid)
table.append([ds.captured_run_id, ds.captured_counter, ds.exp_name,
ds.sample_name,
parsed_guid['sample'], parsed_guid['location'],
parsed_guid['work_station']])
return tabulate(table, headers=headers)
def make_test_guid(cfg, loc: int, smpl: int, stat: int):
cfg['GUID_components']['location'] = loc
cfg['GUID_components']['work_station'] = stat
cfg['GUID_components']['sample'] = smpl
guid = generate_guid()
gen_time = int(np.round(time.time() * 1000))
comps = parse_guid(guid)
assert comps['location'] == loc
assert comps['work_station'] == stat
assert comps['sample'] == smpl
assert comps['time'] - gen_time < 2
return guid
def test_generate_guid(loc, stat, smpl):
# update config to generate a particular guid. Read it back to verify
with default_config():
cfg = qc.config
cfg['GUID_components']['location'] = loc
cfg['GUID_components']['work_station'] = stat
cfg['GUID_components']['sample'] = smpl
guid = generate_guid()
gen_time = int(np.round(time.time() * 1000))
comps = parse_guid(guid)
if smpl == 0:
smpl = int('a' * 8, base=16)
assert comps['location'] == loc
assert comps['work_station'] == stat
assert comps['sample'] == smpl
assert comps['time'] - gen_time < 2
def test_guid(dataset):
guid = dataset.guid
assert len(guid) == 36
parse_guid(guid)
def test_update_existing_guids(caplog):
old_loc = 101
old_ws = 1200
new_loc = 232
new_ws = 52123
# prepare five runs with different location and work station codes
with location_and_station_set_to(0, 0):
new_experiment('test', sample_name='test_sample')
ds1 = new_data_set('ds_one')
xparam = ParamSpec('x', 'numeric')
ds1.add_parameter(xparam)
ds1.add_result({'x': 1})
ds2 = new_data_set('ds_two')
ds2.add_parameter(xparam)
ds2.add_result({'x': 2})
guid_comps_1 = parse_guid(ds1.guid)
assert guid_comps_1['location'] == 0
assert guid_comps_1['work_station'] == 0
guid_comps_2 = parse_guid(ds2.guid)
assert guid_comps_2['location'] == 0
assert guid_comps_2['work_station'] == 0
with location_and_station_set_to(0, old_ws):
ds3 = new_data_set('ds_three')
xparam = ParamSpec('x', 'numeric')
ds3.add_parameter(xparam)
ds3.add_result({'x': 3})
with location_and_station_set_to(old_loc, 0):
ds4 = new_data_set('ds_four')
xparam = ParamSpec('x', 'numeric')
ds4.add_parameter(xparam)
ds4.add_result({'x': 4})
with location_and_station_set_to(old_loc, old_ws):
ds5 = new_data_set('ds_five')
xparam = ParamSpec('x', 'numeric')
ds5.add_parameter(xparam)
ds5.add_result({'x': 5})
with location_and_station_set_to(new_loc, new_ws):
caplog.clear()
expected_levels = [
'INFO', 'INFO', 'INFO', 'INFO', 'INFO', 'INFO', 'WARNING', 'INFO',
'WARNING', 'INFO', 'INFO'
]
with caplog.at_level(logging.INFO):
update_GUIDs(ds1.conn)
for record, lvl in zip(caplog.records, expected_levels):
assert record.levelname == lvl
guid_comps_1 = parse_guid(ds1.guid)
assert guid_comps_1['location'] == new_loc
assert guid_comps_1['work_station'] == new_ws
guid_comps_2 = parse_guid(ds2.guid)
assert guid_comps_2['location'] == new_loc
assert guid_comps_2['work_station'] == new_ws
guid_comps_3 = parse_guid(ds3.guid)
assert guid_comps_3['location'] == 0
assert guid_comps_3['work_station'] == old_ws
guid_comps_4 = parse_guid(ds4.guid)
assert guid_comps_4['location'] == old_loc
assert guid_comps_4['work_station'] == 0
guid_comps_5 = parse_guid(ds5.guid)
assert guid_comps_5['location'] == old_loc
assert guid_comps_5['work_station'] == old_ws
def _assert_loc_station(ds, expected_loc, expected_station):
guid_dict = parse_guid(ds.guid)
assert guid_dict["location"] == expected_loc
assert guid_dict["work_station"] == expected_station
def update_GUIDs(conn: ConnectionPlus) -> None:
"""
Update all GUIDs in this database where either the location code or the
work_station code is zero to use the location and work_station code from
the qcodesrc.json file in home. Runs where it is not true that both codes
are zero are skipped.
"""
log.info('Commencing update of all GUIDs in database')
cfg = qc.Config()
location = cfg['GUID_components']['location']
work_station = cfg['GUID_components']['work_station']
if location == 0:
log.warning('The location is still set to the default (0). Can not '
'proceed. Please configure the location before updating '
'the GUIDs.')
return
if work_station == 0:
log.warning('The work_station is still set to the default (0). Can not'
' proceed. Please configure the location before updating '
'the GUIDs.')
return
query = f"select MAX(run_id) from runs"
c = atomic_transaction(conn, query)
no_of_runs = c.fetchall()[0][0]
# now, there are four actions we can take
def _both_nonzero(run_id: int, *args) -> None:
log.info(f'Run number {run_id} already has a valid GUID, skipping.')
def _location_only_zero(run_id: int, *args) -> None:
log.warning(f'Run number {run_id} has a zero (default) location '
'code, but a non-zero work station code. Please manually '
'resolve this, skipping the run now.')
def _workstation_only_zero(run_id: int, *args) -> None:
log.warning(f'Run number {run_id} has a zero (default) work station'
' code, but a non-zero location code. Please manually '
'resolve this, skipping the run now.')
def _both_zero(run_id: int, conn, guid_comps) -> None:
guid_str = generate_guid(timeint=guid_comps['time'],
sampleint=guid_comps['sample'])
with atomic(conn) as conn:
sql = f"""
UPDATE runs
SET guid = ?
where run_id == {run_id}
"""
cur = conn.cursor()
cur.execute(sql, (guid_str, ))
log.info(f'Succesfully updated run number {run_id}.')
actions: Dict[Tuple[bool, bool], Callable]
actions = {
(True, True): _both_zero,
(False, True): _workstation_only_zero,
(True, False): _location_only_zero,
(False, False): _both_nonzero
}
for run_id in range(1, no_of_runs + 1):
guid_str = get_guid_from_run_id(conn, run_id)
guid_comps = parse_guid(guid_str)
loc = guid_comps['location']
ws = guid_comps['work_station']
log.info(f'Updating run number {run_id}...')
actions[(loc == 0, ws == 0)](run_id, conn, guid_comps)
