docs: def reads(paths, filename='data.h5', options=None, **keywords):
      """ Reads data from an HDF5 file (high level).
  
      High level function to read one or more pieces of data from an HDF5
      file located at the paths specified in `paths` into Python
      types. Each path is specified as a POSIX style path where the data
      to read is located.
  
      There are various options that can be used to influence how the data
      is read. They can be passed as an already constructed ``Options``
      into `options` or as additional keywords that will be used to make
      one by ``options = Options(**keywords)``.
  
      Paths are POSIX style and can either be given directly as ``str`` or
      ``bytes``, or the separated path can be given as an iterable of
      ``str`` and ``bytes``. Each part of a separated path is escaped
      using ``utilities.escape_path``. Otherwise, the path is assumed to
      be already escaped. Escaping is done so that targets with a part
      that starts with one or more periods, contain slashes, and/or
      contain nulls can be used without causing the wrong Group to be
      looked in or the wrong target to be looked at. It essentially allows
      one to make a Dataset named ``'..'`` or ``'a/a'`` instead of moving
      around in the Dataset hierarchy.
  
      Parameters
      ----------
      paths : iterable of paths
          An iterable of paths to read data from. Each must be a POSIX
          style path where the directory name is the Group to put it in
          and the basename is the name to write it to. The format of
          paths is described in the paragraph above.
      filename : str, optional
          The name of the HDF5 file to read data from.
      options : Options, optional
          The options to use when reading. Is mutually exclusive with any
          additional keyword arguments given (set to ``None`` or don't
          provide to use them).
      **keywords :
          If `options` was not provided or was ``None``, these are used as
          arguments to make a ``Options``.
  
      Returns
      -------
      datas : iterable
          An iterable holding the piece of data for each path in `paths`
          in the same order.
  
      Raises
      ------
      exceptions.CantReadError
          If reading the data can't be done.
  
      See Also
      --------
      utilities.process_path
      utilities.escape_path
      read : Reads just a single piece of data
      writes
      write
      Options
      utilities.read_data : Low level version.
  
      """
      # Pack the different options into an Options class if an Options was
      # not given. By default, the matlab_compatible option is set to
      # False. So, if it wasn't passed in the keywords, this needs to be
      # added to override the default value (True) for a new Options.
      if not isinstance(options, Options):
          kw = copy.deepcopy(keywords)
          if 'matlab_compatible' not in kw:
              kw['matlab_compatible'] = False
          options = Options(**kw)
  
      # Process the paths and stuff the group names and target names as
      # tuples into toread.
      toread = []
      for p in paths:
          groupname, targetname = utilities.process_path(p)
  
          # Pack them into toread
          toread.append((groupname, targetname))
  
      # Open the hdf5 file and start reading the data. This is all wrapped
      # in a try block, so that the file can be closed if any errors
      # happen (the error is re-raised).
      try:
          f = None
          f = h5py.File(filename, mode='r')
  
          # Read the data item by item
          datas = []
          for groupname, targetname in toread:
              # Check that the containing group is in f and is indeed a
              # group. If it isn't an error needs to be thrown.
              if groupname not in f \
                      or not isinstance(f[groupname], h5py.Group):
                  raise exceptions.CantReadError( \
                      'Could not find containing Group ' \
                      + groupname + '.')
  
              # Hand off everything to the low level reader.
              datas.append(utilities.read_data(f, f[groupname],
                                               targetname, options))
      except:
          raise
      finally:
          if f is not None:
              f.close()
  
      return datas