docs: def load_all(path, include_core=True, subfolders=None, path_in_arc=None):
      """ Loads a full IO system with all extension in path
  
      Parameters
      ----------
      path : pathlib.Path or string
          Path or path with para file name for the data to load.
          This must either point to the directory containing the uncompressed
          data or the location of a compressed zip file with the data. In the
          later case and if there are several mrio's in the zip file the
          parameter 'path_in_arc' need to be specifiec to further indicate the
          location of the data in the compressed file.
  
      include_core : boolean, optional
          If False the load method does not include A, L and Z matrix. This
          significantly reduces the required memory if the purpose is only
          to analyse the results calculated beforehand.
  
      subfolders: list of pathlib.Path or string, optional
          By default (subfolders=None), all subfolders in path containing a json
          parameter file (as defined in DEFAULT_FILE_NAMES['filepara']:
          metadata.json) are parsed. If only a subset should be used, pass a list
          of names of subfolders. These can either be strings specifying direct
          subfolders of path, or absolute/relative path if the extensions are
          stored at a different location. Both modes can be mixed. If the data
          is read from a zip archive the path must be given as described below in
          'path_in_arc', relative to the root defined in the paramter
          'path_in_arc'. Extensions in a different zip archive must be read
          separately by calling the function 'load' for this extension.
  
      path_in_arc: string, optional
          Path to the data in the zip file (where the fileparameters file is
          located). path_in_arc must be given without leading dot and slash;
          thus to point to the data in the root of the compressed file pass '',
          for data in e.g. the folder 'emissions' pass 'emissions/'.  Only used
          if parameter 'path' points to an compressed zip file.
          Can be None (default) if there is only one mrio database in the
          zip archive (thus only one file_parameter file as the systemtype entry
          'IOSystem'.
  
      """
      def clean(varStr):
          """ get valid python name from folder
          """
          return re.sub('\W|^(?=\d)', '_', str(varStr))
  
      path = Path(path)
  
      if zipfile.is_zipfile(str(path)):
          with zipfile.ZipFile(file=str(path), mode='r') as zz:
              zipcontent = zz.namelist()
          if path_in_arc:
              path_in_arc = str(path_in_arc)
              if path_in_arc not in zipcontent:
                  path_in_arc = os.path.join(path_in_arc,
                                             DEFAULT_FILE_NAMES['filepara'])
                  if path_in_arc not in zipcontent:
                      raise ReadError('File parameter file {} not found in {}. '
                                      'Tip: specify fileparameter filename '
                                      'through "path_in_arc" if different '
                                      'from default.'.format(
                                          DEFAULT_FILE_NAMES['filepara'], path))
  
          else:
              with zipfile.ZipFile(file=str(path), mode='r') as zz:
                  fpfiles = [
                      f for f in zz.namelist()
                      if
                      os.path.basename(f) == DEFAULT_FILE_NAMES['filepara'] and
                      json.loads(zz.read(f).decode('utf-8')
                                 )['systemtype'] == 'IOSystem']
              if len(fpfiles) == 0:
                  raise ReadError('File parameter file {} not found in {}. '
                                  'Tip: specify fileparameter filename '
                                  'through "path_in_arc" if different '
                                  'from default.'.format(
                                      DEFAULT_FILE_NAMES['filepara'], path))
              elif len(fpfiles) > 1:
                  raise ReadError('Mulitple mrio archives found in {}. '
                                  'Specify one by the '
                                  'parameter "path_in_arc"'.format(path))
              else:
                  path_in_arc = os.path.dirname(fpfiles[0])
  
          logging.debug("Expect file parameter-file at {} in {}".format(
              path_in_arc, path))
  
      io = load(path, include_core=include_core, path_in_arc=path_in_arc)
  
      if zipfile.is_zipfile(str(path)):
          root_in_zip = os.path.dirname(path_in_arc)
          if subfolders is None:
              subfolders = {
                  os.path.relpath(os.path.dirname(p), root_in_zip)
                  for p in zipcontent
                  if p.startswith(root_in_zip) and
                  os.path.dirname(p) != root_in_zip}
  
          for subfolder_name in subfolders:
              if subfolder_name not in zipcontent + list({
                      os.path.dirname(p) for p in zipcontent}):
                  subfolder_full = os.path.join(root_in_zip, subfolder_name)
              else:
                  subfolder_full = subfolder_name
              subfolder_name = os.path.basename(os.path.normpath(subfolder_name))
  
              if subfolder_name not in zipcontent:
                  subfolder_full_meta = os.path.join(
                      subfolder_full, DEFAULT_FILE_NAMES['filepara'])
              else:
                  subfolder_full_meta = subfolder_full
  
              if subfolder_full_meta in zipcontent:
                  ext = load(path,
                             include_core=include_core,
                             path_in_arc=subfolder_full_meta)
                  setattr(io, clean(subfolder_name), ext)
                  io.meta._add_fileio("Added satellite account "
                                      "from {}".format(subfolder_full))
              else:
                  continue
  
      else:
          if subfolders is None:
              subfolders = [d for d in path.iterdir() if d.is_dir()]
  
          for subfolder_name in subfolders:
              if not os.path.exists(str(subfolder_name)):
                  subfolder_full = path / subfolder_name
              else:
                  subfolder_full = subfolder_name
              subfolder_name = os.path.basename(os.path.normpath(subfolder_name))
  
              if not os.path.isfile(str(subfolder_full)):
                  subfolder_full_meta = (subfolder_full /
                                         DEFAULT_FILE_NAMES['filepara'])
              else:
                  subfolder_full_meta = subfolder_full
  
              if subfolder_full_meta.exists():
                  ext = load(subfolder_full, include_core=include_core)
                  setattr(io, clean(subfolder_name), ext)
                  io.meta._add_fileio("Added satellite account "
                                      "from {}".format(subfolder_full))
              else:
                  continue
  
      return io