docs: def _load_nonlink_level(handler, level, pathtable, pathname):
      """
      Loads level and builds appropriate type, without handling softlinks
      """
      if isinstance(level, tables.Group):
          if _sns and (level._v_title.startswith('SimpleNamespace:') or
                       DEEPDISH_IO_ROOT_IS_SNS in level._v_attrs):
              val = SimpleNamespace()
              dct = val.__dict__
          elif level._v_title.startswith('list:'):
              dct = {}
              val = []
          else:
              dct = {}
              val = dct
          # in case of recursion, object needs to be put in pathtable
          # before trying to fully load it
          pathtable[pathname] = val
  
          # Load sub-groups
          for grp in level:
              lev = _load_level(handler, grp, pathtable)
              n = grp._v_name
              # Check if it's a complicated pair or a string-value pair
              if n.startswith('__pair'):
                  dct[lev['key']] = lev['value']
              else:
                  dct[n] = lev
  
          # Load attributes
          for name in level._v_attrs._f_list():
              if name.startswith(DEEPDISH_IO_PREFIX):
                  continue
              v = level._v_attrs[name]
              dct[name] = v
  
          if level._v_title.startswith('list:'):
              N = int(level._v_title[len('list:'):])
              for i in range(N):
                  val.append(dct['i{}'.format(i)])
              return val
          elif level._v_title.startswith('tuple:'):
              N = int(level._v_title[len('tuple:'):])
              lst = []
              for i in range(N):
                  lst.append(dct['i{}'.format(i)])
              return tuple(lst)
          elif level._v_title.startswith('nonetype:'):
              return None
          elif is_pandas_dataframe(level):
              assert _pandas, "pandas is required to read this file"
              store = _HDFStoreWithHandle(handler)
              return store.get(level._v_pathname)
          elif level._v_title.startswith('sparse:'):
              frm = level._v_attrs.format
              if frm in ('csr', 'csc', 'bsr'):
                  shape = tuple(level.shape[:])
                  cls = {'csr': sparse.csr_matrix,
                         'csc': sparse.csc_matrix,
                         'bsr': sparse.bsr_matrix}
                  matrix = cls[frm](shape)
                  matrix.data = level.data[:]
                  matrix.indices = level.indices[:]
                  matrix.indptr = level.indptr[:]
                  matrix.maxprint = level._v_attrs.maxprint
                  return matrix
              elif frm == 'dia':
                  shape = tuple(level.shape[:])
                  matrix = sparse.dia_matrix(shape)
                  matrix.data = level.data[:]
                  matrix.offsets = level.offsets[:]
                  matrix.maxprint = level._v_attrs.maxprint
                  return matrix
              elif frm == 'coo':
                  shape = tuple(level.shape[:])
                  matrix = sparse.coo_matrix(shape)
                  matrix.data = level.data[:]
                  matrix.col = level.col[:]
                  matrix.row = level.row[:]
                  matrix.maxprint = level._v_attrs.maxprint
                  return matrix
              else:
                  raise ValueError('Unknown sparse matrix type: {}'.format(frm))
          else:
              return val
  
      elif isinstance(level, tables.VLArray):
          if level.shape == (1,):
              return _load_pickled(level)
          else:
              return level[:]
  
      elif isinstance(level, tables.Array):
          if 'zeroarray_dtype' in level._v_attrs:
              # Unpack zero-size arrays (shape is stored in an HDF5 array and
              # type is stored in the attibute 'zeroarray_dtype')
              dtype = level._v_attrs.zeroarray_dtype
              sh = level[:]
              return np.zeros(tuple(sh), dtype=dtype)
  
          if 'strtype' in level._v_attrs:
              strtype = level._v_attrs.strtype
              itemsize = level._v_attrs.itemsize
              if strtype == b'unicode':
                  return level[:].view(dtype=(np.unicode_, itemsize))
              elif strtype == b'ascii':
                  return level[:].view(dtype=(np.string_, itemsize))
          # This serves two purposes:
          # (1) unpack big integers: the only time we save arrays like this
          # (2) unpack non-deepdish "scalars"
          if level.shape == ():
              return level[()]
  
          return level[:]