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)