docs: def load_and_append(probe_dict, probes, instruments={}):
          """
          load probes from probe_dict and append to probes, if additional instruments are required create them and add them to instruments
  
          Args:
              probe_dict: dictionary of form
  
                  probe_dict = {
                      instrument1_name : probe1_of_instrument1, probe2_of_instrument1, ...
                      instrument2_name : probe1_of_instrument2, probe2_of_instrument2, ...
                  }
  
              where probe1_of_instrument1 is a valid name of a probe in instrument of class instrument1_name
  
              # optional arguments (as key value pairs):
              #     probe_name
              #     instrument_name
              #     probe_info
              #     buffer_length
              #
              #
              # or
              #     probe_dict = {
              #     name_of_probe_1 : instrument_class_1
              #     name_of_probe_2 : instrument_class_2
              #     ...
              #     }
  
  
              probes: dictionary of form
                  probe_dict = {
                      instrument1_name:
                          {name_of_probe_1_of_instrument1 : probe_1_instance,
                           name_of_probe_2_instrument1 : probe_2_instance
                           }
                           , ...}
  
              instruments: dictionary of form
  
                  instruments = {
                  name_of_instrument_1 : instance_of_instrument_1,
                  name_of_instrument_2 : instance_of_instrument_2,
                  ...
                  }
      Returns:
                  updated_probes = { name_of_probe_1 : probe_1_instance, name_of_probe_2 : probe_2_instance, ...}
                  loaded_failed = {name_of_probe_1: exception_1, name_of_probe_2: exception_2, ....}
                  updated_instruments
          """
  
  
          loaded_failed = {}
          updated_probes = {}
          updated_probes.update(probes)
          updated_instruments = {}
          updated_instruments.update(instruments)
  
          # =====  load new instruments =======
          new_instruments = list(set(probe_dict.keys())-set(probes.keys()))
          if new_instruments != []:
              updated_instruments, failed = Instrument.load_and_append({instrument_name: instrument_name for instrument_name in new_instruments}, instruments)
  
  
              if failed != []:
                  # if loading an instrument fails all the probes that depend on that instrument also fail
                  # ignore the failed instrument that did exist already because they failed because they did exist
                  for failed_instrument in set(failed) - set(instruments.keys()):
                      for probe_name in probe_dict[failed_instrument]:
                          loaded_failed[probe_name] = ValueError('failed to load instrument {:s} already exists. Did not load!'.format(failed_instrument))
                      del probe_dict[failed_instrument]
  
          # =====  now we are sure that all the instruments that we need for the probes already exist
  
  
          for instrument_name, probe_names in probe_dict.items():
              if not instrument_name in updated_probes:
                  updated_probes.update({instrument_name:{}})
  
              for probe_name in probe_names.split(','):
                  if probe_name in updated_probes[instrument_name]:
                      loaded_failed[probe_name] = ValueError('failed to load probe {:s} already exists. Did not load!'.format(probe_name))
                  else:
                      probe_instance = Probe(updated_instruments[instrument_name], probe_name)
                      updated_probes[instrument_name].update({probe_name: probe_instance})
  
          return updated_probes, loaded_failed, updated_instruments