def get_data_from_hdf_file(timestamp=None, data_file=None, close_file=True, file_id=None, mode='r'): """ Return the measurement data stored in Experimental Data group of the file specified by timestamp. :param timestamp: (str) measurement timestamp of form YYYYMMDD_hhmmsss :param data_file: (HDF file) opened HDF5 file :param close_file: (bool) whether to close the HDF5 file :return: numpy array with measurement data """ if data_file is None: if timestamp is None: raise ValueError('Please provide either timestamp or data_file.') folder = a_tools.get_folder(timestamp) h5filepath = a_tools.measurement_filename(folder, file_id=file_id) data_file = h5py.File(h5filepath, mode) try: group = data_file['Experimental Data'] if 'Data' in group: dataset = np.array(group['Data']) else: raise KeyError('Data was not found in Experimental Data.') if close_file: data_file.close() except Exception as e: data_file.close() raise e return dataset
def _fill_experimental_values_with_ReparkingRamsey(experimental_values, timestamp, qubit): """ Fills the experimental_values dictionary with the experimental values from ReparkingRamsey experiments. NOTE if there are multiple measurements of the same transition at the same voltage, the (chronological) last one will be used. Arguments: experimental_values: dictionary to fill with experimental data timestamp: timestamp qubit: qubit (qubit object) or qubit name (str) """ path = a_tools.data_from_time(timestamp) filepath = a_tools.measurement_filename(path) data = h5py.File(filepath, "r") if "_ge_" in filepath: transition = "ge" elif "_ef_" in filepath: transition = "ef" else: log.warning( "Transition not recognized. Only ge and ef transitions " "are supported.") return if type(qubit) is str: qubit_name = qubit else: qubit_name = qubit.name if not qubit_name in filepath: return try: dc_voltages = np.array(data["Experimental Data"] ["Experimental Metadata"]["dc_voltages"]) for i in range(len(dc_voltages)): freq = float( np.array(data["Analysis"]["Processed data"] ["analysis_params_dict"][ qubit_name + f"_" f"{i}"]["exp_decay"].attrs["new_qb_freq"])) freq_std = float( np.array(data["Analysis"]["Processed data"] ["analysis_params_dict"][ qubit_name + f"_" f"{i}"]["exp_decay"].attrs["new_qb_freq"])) voltage = dc_voltages[i] HamiltonianFittingAnalysis._fill_experimental_values( experimental_values, voltage, transition, freq) except: log.warning( "Could not get reparking data from file {}".format(filepath))
def test_save_quantities_of_interest(self): # Test based on test below to get a dummy dataset ts = '20161124_162604' a = ba.BaseDataAnalysis() a.proc_data_dict['quantities_of_interest'] = {'a': 5} a.timestamps = [ts] a.save_quantities_of_interest() fn = a_tools.measurement_filename(a_tools.data_from_time(ts)) with h5py.File(fn, 'r') as file: saved_val = float(file['Analysis']['quantities_of_interest'].attrs['a']) assert saved_val == 5
def _fill_experimental_values_with_Ramsey(experimental_values, timestamp, qubit, fluxlines_dict): """ Fills the experimental_values dictionary with the experimental values from Ramsey experiments. NOTE if there are multiple measurements of the same transition at the same voltage, the (chronological) last one will be used. Arguments: experimental_values: dictionary containing the experimental values timestamp: timestamp qubit: qubit (qubit object) or qubit name (str) fluxlines_dict: dictionary containing the fluxline ids (necessary to determine voltage) """ path = a_tools.data_from_time(timestamp) filepath = a_tools.measurement_filename(path) data = h5py.File(filepath, "r") if "_ge_" in filepath: transition = "ge" elif "_ef_" in filepath: transition = "ef" else: raise ValueError("Transition not recognized. Only ge and ef " "transitions are supported.") if type(qubit) is str: qubit_name = qubit else: qubit_name = qubit.name if not qubit_name in filepath: return try: freq = data["Analysis"]["Processed data"]["analysis_params_dict"][ qubit_name]["exp_decay"].attrs["new_qb_freq"] freq_std = data["Analysis"]["Processed data"][ "analysis_params_dict"][qubit_name]["exp_decay"].attrs[ "new_qb_freq_stderr"] voltage = float(data["Instrument settings"]["DCSource"].attrs[ fluxlines_dict[qubit_name].name]) HamiltonianFittingAnalysis._fill_experimental_values( experimental_values, voltage, transition, freq) except KeyError: log.warning(f"Could not get ramsey data from file {filepath}")
def test_save_fit_results(self): # strictly speaking an integration test as it relies on the cond # oscillation analysis, but the only thing tested here is # if the value of the fit_result is saved. ts = '20181126_131143' a = ma2.Conditional_Oscillation_Analysis(t_start=ts) exp_val = a.fit_res['cos_fit_off'].params['amplitude'].value fn = a_tools.measurement_filename(a_tools.data_from_time(ts)) with h5py.File(fn, 'r') as file: saved_val = float(file['Analysis']['cos_fit_off']['params'] ['amplitude'].attrs['value']) a.fit_res = {} a.save_fit_results() assert exp_val == saved_val
def get_value_names_from_timestamp(timestamp, file_id=None, mode='r'): """ Returns value_names from the HDF5 file specified by timestamp. :param timestamp: (str) measurement timestamp of form YYYYMMDD_hhmmsss :return: list of value_names """ folder = a_tools.get_folder(timestamp) h5filepath = a_tools.measurement_filename(folder, file_id=file_id) data_file = h5py.File(h5filepath, mode) try: channel_names = get_hdf_param_value(data_file['Experimental Data'], 'value_names') data_file.close() return channel_names except Exception as e: data_file.close() raise e
def get_param_from_metadata_group(timestamp=None, param_name=None, file_id=None, data_file=None, close_file=True, mode='r'): """ Get a parameter with param_name from the Experimental Metadata group in the HDF5 file specified by timestamp, or return the whole group if param_name is None. :param timestamp: (str) measurement timestamp of form YYYYMMDD_hhmmsss :param param_name: (str) name of a key in Experimental Metadata group :param data_file: (HDF file) opened HDF5 file :param close_file: (bool) whether to close the HDF5 file :return: the value of the param_name or the whole experimental metadata dictionary """ if data_file is None: if timestamp is None: raise ValueError('Please provide either timestamp or data_file.') folder = a_tools.get_folder(timestamp) h5filepath = a_tools.measurement_filename(folder, file_id=file_id) data_file = h5py.File(h5filepath, mode) try: if param_name is None: group = data_file['Experimental Data'] return read_dict_from_hdf5({}, group['Experimental Metadata']) group = data_file['Experimental Data']['Experimental Metadata'] if param_name in group: group = group[param_name] param_value = OrderedDict() if isinstance(group, h5py._hl.dataset.Dataset): param_value = list(np.array(group).flatten()) param_value = [x.decode('utf-8') if isinstance(x, bytes) else x for x in param_value] else: param_value = read_dict_from_hdf5(param_value, group) elif param_name in group.attrs: param_value = get_hdf_param_value(group, param_name) else: raise KeyError(f'{param_name} was not found in metadata.') if close_file: data_file.close() except Exception as e: data_file.close() raise e return param_value
def open_hdf_file(timestamp=None, folder=None, filepath=None, mode='r', file_id=None): """ Opens the hdf5 file with flexible input parameters. If no parameter is given, opens the hdf5 of the last measurement in reading mode. Args: :param timestamp: (str) measurement timestamp of form YYYYMMDD_hhmmsss :param folder: (str) path to file location :param mode filepath: (str) path to hdf5 file. Overwrites timestamp and folder :param mode: (str) mode to open the file ('r' for read), ('r+' for read/write) :param file_id: (str) file id :return: opened HDF5 file """ if filepath is None: if folder is None: assert timestamp is not None folder = a_tools.get_folder(timestamp) filepath = a_tools.measurement_filename(folder, file_id=file_id) return h5py.File(filepath, mode)
def read_analysis_file(timestamp=None, filepath=None, data_dict=None, file_id=None, ana_file=None, close_file=True, mode='r'): """ Creates a data_dict from an AnalysisResults file as generated by analysis_v3 :param timestamp: str with a measurement timestamp :param filepath: (str) path to file :param data_dict: dict where to store the file entries :param file_id: suffix to the usual HDF measurement file found from giving a measurement timestamp. Defaults to '_AnalysisResults,' the standard suffix created by analysis_v3 :param ana_file: HDF file instance :param close_file: whether to close the HDF file at the end :param mode: str specifying the HDF read mode (if ana_file is None) :return: the data dictionary """ if data_dict is None: data_dict = {} try: if ana_file is None: if filepath is None: if file_id is None: file_id = 'AnalysisResults' folder = a_tools.get_folder(timestamp) filepath = a_tools.measurement_filename(folder, file_id=f'_{file_id}') ana_file = h5py.File(filepath, mode) read_from_hdf(data_dict, ana_file) if close_file: ana_file.close() except Exception as e: if close_file: try: ana_file.close() except AttributeError: # there was an exception before reaching the line above where # ana_file is opened pass raise e return data_dict
def load_settings_onto_instrument(instrument, load_from_instr=None, folder=None, label=None, timestamp=None, **kw): ''' Loads settings from an hdf5 file onto the instrument handed to the function. By default uses the last hdf5 file in the datadirectory. By giving a label or timestamp another file can be chosen as the settings file. ''' older_than = None instrument_name = instrument.name success = False count = 0 while success is False and count < 10: try: if folder is None: folder = a_tools.get_folder(timestamp, older_than, **kw) else: folder = folder filepath = a_tools.measurement_filename(folder) f = h5py.File(filepath, 'r') sets_group = f['Instrument settings'] if load_from_instr is None: ins_group = sets_group[instrument_name] else: ins_group = sets_group[load_from_instr] print('Loaded Settings Successfully') success = True except: older_than = os.path.split(folder)[0][-8:] \ +'_'+ os.path.split(folder)[1][:6] folder = None success = False count += 1 if not success: print('Could not open settings for instrument "%s"' % ( instrument_name)) return False for parameter, value in ins_group.attrs.items(): if value != 'None': # None is saved as string in hdf5 if type(value) == str: if value == 'False': instrument.set(parameter, False) else: try: instrument.set(parameter, float(value)) except Exception: try: instrument.set(parameter, value) except: print('Could not set parameter: "%s" to "%s" for instrument "%s"' % ( parameter, value, instrument_name)) except Exception: try: instrument.set(parameter, int(value)) except: print('Could not set parameter: "%s" to "%s" for instrument "%s"' % ( parameter, value, instrument_name)) else: instrument.set(parameter, value) f.close() return True
def load_settings_onto_instrument_v2( instrument, load_from_instr: str = None, label: str = "", filepath: str = None, timestamp: str = None, ignore_pars: set = None, ): """ Loads settings from an hdf5 file onto the instrument handed to the function. By default uses the last hdf5 file in the datadirectory. By giving a label or timestamp another file can be chosen as the settings file. Args: instrument (instrument) : instrument onto which settings should be loaded load_from_instr (str) : optional name of another instrument from which to load the settings. label (str) : label used for finding the last datafile filepath (str) : exact filepath of the hdf5 file to load. if filepath is specified, this takes precedence over the file locating options (label, timestamp etc.). timestamp (str) : timestamp of file in the datadir """ older_than = None folder = None instrument_name = instrument.name success = False count = 0 # Will try multiple times in case the last measurements failed and # created corrupt data files. while success is False and count < 3: if filepath is None: folder = a_tools.get_folder( timestamp=timestamp, label=label, older_than=older_than ) filepath = a_tools.measurement_filename(folder) try: f = h5py.File(filepath, "r") snapshot = {} read_dict_from_hdf5(snapshot, h5_group=f["Snapshot"]) if load_from_instr is None: ins_group = snapshot["instruments"][instrument_name] else: ins_group = snapshot["instruments"][load_from_instr] success = True except Exception as e: logging.warning("Exception occured reading from {}".format(folder)) logging.warning(e) # This check makes this snippet a bit more robust if folder is not None: older_than = ( os.path.split(folder)[0][-8:] + "_" + os.path.split(folder)[1][:6] ) # important to set all to None, otherwise the try except loop # will not look for an earlier data file folder = None filepath = None success = False count += 1 if not success: logging.warning( 'Could not open settings for instrument "%s"' % (instrument_name) ) return False for parname, par in ins_group["parameters"].items(): try: if hasattr(instrument.parameters[parname], "set") and ( par["value"] is not None ): if ignore_pars is None or parname not in ignore_pars: par_value = par["value"] if type(par_value) == str: try: instrument.parameters[parname].validate(par_value) except TypeError: # This detects that in the hdf5 file the parameter # was saved as string due to type incompatibility par_value = eval(par_value) instrument.set(parname, par_value) except Exception as e: print( 'Could not set parameter: "{}" to "{}" ' 'for instrument "{}"'.format(parname, par["value"], instrument_name) ) logging.warning(e) f.close() return True
def load_settings_onto_instrument( instrument, load_from_instr=None, folder=None, label=None, timestamp=None, **kw ): """ Loads settings from an hdf5 file onto the instrument handed to the function. By default uses the last hdf5 file in the datadirectory. By giving a label or timestamp another file can be chosen as the settings file. """ older_than = None instrument_name = instrument.name success = False count = 0 while success is False and count < 10: try: if folder is None: folder = a_tools.get_folder( timestamp=timestamp, older_than=older_than, **kw ) else: folder = folder filepath = a_tools.measurement_filename(folder) f = h5py.File(filepath, "r") sets_group = f["Instrument settings"] if load_from_instr is None: ins_group = sets_group[instrument_name] else: ins_group = sets_group[load_from_instr] print("Loaded Settings Successfully") success = True except: older_than = ( os.path.split(folder)[0][-8:] + "_" + os.path.split(folder)[1][:6] ) folder = None success = False count += 1 if not success: print('Could not open settings for instrument "%s"' % (instrument_name)) return False for parameter, value in ins_group.attrs.items(): if value != "None": # None is saved as string in hdf5 if type(value) == str: if value == "False": try: instrument.set(parameter, False) except: print( 'Could not set parameter: "%s" to "%s" for instrument "%s"' % (parameter, value, instrument_name) ) else: try: instrument.set(parameter, float(value)) except Exception: try: instrument.set(parameter, value) except: try: instrument.set(parameter, int(value)) except: print( 'Could not set parameter: "%s" to "%s" for instrument "%s"' % (parameter, value, instrument_name) ) else: instrument.set(parameter, value) f.close() return True
def load_settings_onto_instrument_v2(instrument, load_from_instr: str = None, label: str = '', filepath: str = None, timestamp: str = None): ''' Loads settings from an hdf5 file onto the instrument handed to the function. By default uses the last hdf5 file in the datadirectory. By giving a label or timestamp another file can be chosen as the settings file. Args: instrument (instrument) : instrument onto which settings should be loaded load_from_instr (str) : optional name of another instrument from which to load the settings. label (str) : label used for finding the last datafile filepath (str) : exact filepath of the hdf5 file to load. if filepath is specified, this takes precedence over the file locating options (label, timestamp etc.). timestamp (str) : timestamp of file in the datadir ''' older_than = None folder = None instrument_name = instrument.name success = False count = 0 # Will try multiple times in case the last measurements failed and # created corrupt data files. while success is False and count < 3: if filepath is None: folder = a_tools.get_folder(timestamp=timestamp, label=label, older_than=older_than) filepath = a_tools.measurement_filename(folder) try: f = h5py.File(filepath, 'r') snapshot = {} h5d.read_dict_from_hdf5(snapshot, h5_group=f['Snapshot']) if load_from_instr is None: ins_group = snapshot['instruments'][instrument_name] else: ins_group = snapshot['instruments'][load_from_instr] success = True except Exception as e: logging.warning('Exception occured reading from {}'.format(folder)) logging.warning(e) # This check makes this snippet a bit more robust if folder is not None: older_than = os.path.split(folder)[0][-8:] \ + '_' + os.path.split(folder)[1][:6] # important to set all to None, otherwise the try except loop # will not look for an earlier data file folder = None filepath = None success = False count += 1 if not success: logging.warning('Could not open settings for instrument "%s"' % (instrument_name)) return False for parname, par in ins_group['parameters'].items(): try: if hasattr(instrument.parameters[parname], 'set'): instrument.set(parname, par['value']) except Exception as e: print('Could not set parameter: "{}" to "{}" ' 'for instrument "{}"'.format(parname, par['value'], instrument_name)) logging.warning(e) f.close() return True
def add_measured_data_hdf(data_dict, folder=None, append_data=False, replace_data=False, **params): """ Extracts the dataset from the "Experimental Data" data of an HDF file and stores it in data_dict under "measured_data". Args: data_dict (dict): extracted dataset will be stored here under the key "measured_data" folder (str): full path to an hdf file append_data (bool): if True, and "measured_data" exists in data_dict, the new dataset will be appended replace_data (bool): if True, and "measured_data" exists in data_dict, it will be replaced by the new dataset Keyword args (**params) passed to helper_functions.py/add_param, see docstring there Returns data_dict containing the extracted dataset """ if folder is None: folder = hlp_mod.get_param('folders', data_dict, raise_error=True, **params) if len(folder) > 0: folder = folder[-1] h5mode = hlp_mod.get_param('h5mode', data_dict, default_value='r+', **params) dtype = hlp_mod.get_param('meas_data_dtype', data_dict, default_value=None, **params) if dtype is not None: log.warning(f'Setting Experimental data type: {dtype}') h5filepath = a_tools.measurement_filename(folder) data_file = h5py.File(h5filepath, h5mode) meas_data_array = np.array(data_file['Experimental Data']['Data'], dtype=dtype).T if 'measured_data' in data_dict: if replace_data: data_dict['measured_data'] = meas_data_array data_dict['data_replaced'] = True elif append_data: if not isinstance(data_dict['measured_data'], list): data_dict['measured_data'] = [data_dict['measured_data']] data_dict['measured_data'] += [meas_data_array] data_dict['data_appended'] = True else: raise ValueError( 'Both "append_data" and "replace_data" are False. ' 'Unclear how to add "measured_data" to data_dict.') else: data_dict['measured_data'] = meas_data_array return data_dict
def get_params_from_hdf_file(data_dict, params_dict=None, numeric_params=None, add_param_method=None, folder=None, **params): """ Extracts the parameter provided in params_dict from an HDF file and saves them in data_dict. :param data_dict: OrderedDict where parameters and their values are saved :param params_dict: OrderedDict with key being the parameter name that will be used as key in data_dict for this parameter, and value being a parameter name or a path + parameter name indie the HDF file. :param numeric_params: list of parameter names from amount the keys of params_dict. This specifies that those parameters are numbers and will be converted to floats. :param folder: path to file from which data will be read :param params: keyword arguments: append_value (bool, default: True): whether to append an already-existing key update_value (bool, default: False): whether to replace an already-existing key h5mode (str, default: 'r+'): reading mode of the HDF file close_file (bool, default: True): whether to close the HDF file(s) """ if params_dict is None: params_dict = get_param('params_dict', data_dict, raise_error=True, **params) if numeric_params is None: numeric_params = get_param('numeric_params', data_dict, default_value=[], **params) # if folder is not specified, will take the last folder in the list from # data_dict['folders'] if folder is None: folder = get_param('folders', data_dict, raise_error=True, **params) if len(folder) > 0: folder = folder[-1] h5mode = get_param('h5mode', data_dict, default_value='r', **params) h5filepath = a_tools.measurement_filename(folder, **params) data_file = h5py.File(h5filepath, h5mode) try: for save_par, file_par in params_dict.items(): epd = data_dict all_keys = save_par.split('.') for i in range(len(all_keys)-1): if all_keys[i] not in epd: epd[all_keys[i]] = OrderedDict() epd = epd[all_keys[i]] if isinstance(epd, list): epd = epd[-1] if file_par == 'measurementstring': add_param(all_keys[-1], [os.path.split(folder)[1][7:]], epd, add_param_method='append') continue group_name = '/'.join(file_par.split('.')[:-1]) par_name = file_par.split('.')[-1] if group_name == '': group = data_file attrs = [] else: group = data_file[group_name] attrs = list(group.attrs) if group_name in data_file or group_name == '': if par_name in attrs: add_param(all_keys[-1], get_hdf_param_value(group, par_name), epd, add_param_method=add_param_method) elif par_name in list(group.keys()) or file_par == '': par = group[par_name] if par_name != '' else group if isinstance(par, h5py._hl.dataset.Dataset): add_param(all_keys[-1], np.array(par), epd, add_param_method=add_param_method) else: add_param(all_keys[-1], read_dict_from_hdf5( {}, par), epd, add_param_method=add_param_method) if all_keys[-1] not in epd: # search through the attributes of all groups for group_name in data_file.keys(): if par_name in list(data_file[group_name].attrs): add_param(all_keys[-1], get_hdf_param_value(data_file[group_name], par_name), epd, add_param_method=add_param_method) if all_keys[-1] not in epd: log.warning(f'Parameter {file_par} was not found.') data_file.close() except Exception as e: data_file.close() raise e for par_name in data_dict: if par_name in numeric_params: if hasattr(data_dict[par_name], '__iter__'): data_dict[par_name] = [np.float(p) for p in data_dict[par_name]] data_dict[par_name] = np.asarray(data_dict[par_name]) else: data_dict[par_name] = np.float(data_dict[par_name]) if get_param('close_file', data_dict, default_value=True, **params): data_file.close() else: if 'data_files' in data_dict: data_dict['data_files'] += [data_file] else: data_dict['data_files'] = [data_file] return data_dict
def load_settings(instrument, label: str = '', folder: str = None, timestamp: str = None, update=True, **kw): ''' Loads settings from an hdf5 file onto the instrument handed to the function. By default uses the last hdf5 file in the datadirectory. By giving a label or timestamp another file can be chosen as the settings file. Args: instrument (instrument) : instrument onto which settings should be loaded. Can be an instrument name (str) if update is set to False. label (str) : label used for finding the last datafile folder (str) : exact filepath of the hdf5 file to load. if filepath is specified, this takes precedence over the file locating options (label, timestamp etc.). timestamp (str) : timestamp of file in the datadir update (bool, default True): if set to False, the loaded settings will be returned instead of updating them in the instrument. Kwargs: params_to_set (list) : list of strings referring to the parameters that should be set for the instrument ''' from numpy import array # DO not remove. Used in eval(array(...)) if folder is None: folder_specified = False else: folder_specified = True if isinstance(instrument, str) and not update: instrument_name = instrument else: instrument_name = instrument.name verbose = kw.pop('verbose', True) older_than = kw.pop('older_than', None) success = False count = 0 # Will try multiple times in case the last measurements failed and # created corrupt data files. while success is False and count < 10: if folder is None: folder = a_tools.get_folder(timestamp=timestamp, label=label, older_than=older_than) if verbose: print('Folder used: {}'.format(folder)) try: filepath = a_tools.measurement_filename(folder) f = h5py.File(filepath, 'r') sets_group = f['Instrument settings'] ins_group = sets_group[instrument_name] if verbose: print('Loaded settings successfully from the HDF file.') params_to_set = kw.pop('params_to_set', None) if params_to_set is not None: if len(params_to_set) == 0: log.warning('The list of parameters to update is empty.') if verbose and update: print('Setting parameters {} for {}.'.format( params_to_set, instrument_name)) params_to_set = [(param, val) for (param, val) in ins_group.attrs.items() if param in params_to_set] else: if verbose and update: print('Setting parameters for {}.'.format(instrument_name)) params_to_set = [(param, val) for (param, val) in ins_group.attrs.items() if param not in getattr( instrument, '_params_to_not_load', {})] if not update: params_dict = {parameter : value for parameter, value in \ params_to_set} f.close() return params_dict for parameter, value in params_to_set: if parameter in instrument.parameters.keys() and \ hasattr(instrument.parameters[parameter], 'set'): if value == 'None': # None is saved as string in hdf5 try: instrument.set(parameter, None) except Exception: print('Could not set parameter "%s" to "%s" for ' 'instrument "%s"' % (parameter, value, instrument_name)) elif value == 'False': try: instrument.set(parameter, False) except Exception: print('Could not set parameter "%s" to "%s" for ' 'instrument "%s"' % (parameter, value, instrument_name)) elif value == 'True': try: instrument.set(parameter, True) except Exception: print('Could not set parameter "%s" to "%s" for ' 'instrument "%s"' % (parameter, value, instrument_name)) else: try: instrument.set(parameter, int(value)) except Exception: try: instrument.set(parameter, float(value)) except Exception: try: instrument.set(parameter, eval(value)) except Exception: try: instrument.set(parameter, value) except Exception: log.error('Could not set parameter ' '"%s" to "%s" ' 'for instrument "%s"' % (parameter, value, instrument_name)) success = True f.close() except Exception as e: logging.warning(e) success = False try: f.close() except: pass if timestamp is None and not folder_specified: print('Trying next folder.') older_than = os.path.split(folder)[0][-8:] \ + '_' + os.path.split(folder)[1][:6] folder = None else: break count += 1 if not success: log.error('Could not open settings for instrument {}.'.format( instrument_name)) print() return