docs: def parse_eora26(path, year=None, price='bp', country_names='eora'):
      """ Parse the Eora26 database
  
      Note
      ----
  
      This parser deletes the statistical disrecpancy columns from
      the parsed Eora system (reports the amount of loss in the
      meta recors).
  
      Eora does not provide any information on the unit of the
      monetary values. Based on personal communication the unit
      is set to Mill USD manually.
  
  
      Parameters
      ----------
  
      path : string or pathlib.Path
         Path to the eora raw storage folder or a specific eora zip file to
         parse.  There are several options to specify the data for parsing:
  
         1) Pass the name of eora zip file. In this case the parameters 'year'
            and 'price' will not be used
         2) Pass a folder which eiter contains eora zip files or unpacked eora
            data In that case, a year must be given
         3) Pass a folder which contains subfolders in the format 'YYYY', e.g.
            '1998' This subfolder can either contain an Eora zip file or an
            unpacked Eora system
  
      year : int or str
          4 digit year spec. This will not be used if a zip file
          is specified in 'path'
  
      price : str, optional
          'bp' or 'pp'
  
      country_names: str, optional
          Which country names to use:
          'eora' = Eora flavoured ISO 3 varian
          'full' = Full country names as provided by Eora
          Passing the first letter suffice.
  
  
      """
      path = os.path.abspath(os.path.normpath(str(path)))
  
      if country_names[0].lower() == 'e':
          country_names = 'eora'
      elif country_names[0].lower() == 'f':
          country_names = 'full'
      else:
          raise ParserError('Parameter country_names must be eora or full')
  
      row_name = 'ROW'
      eora_zip_ext = '.zip'
      is_zip = False
  
      # determine which eora file to be parsed
      if os.path.splitext(path)[1] == eora_zip_ext:
          # case direct pass of eora zipfile
          year = re.search(r'\d\d\d\d',
                           os.path.basename(path)).group(0)
          price = re.search(r'bp|pp',
                            os.path.basename(path)).group(0)
          eora_loc = path
          root_path = os.path.split(path)[0]
          is_zip = True
      else:
          root_path = path
          if str(year) in os.listdir(path):
              path = os.path.join(path, str(year))
  
          eora_file_list = [fl for fl in os.listdir(path)
                            if os.path.splitext(fl)[1] == eora_zip_ext and
                            str(year) in fl and
                            str(price) in fl
                            ]
  
          if len(eora_file_list) > 1:
              raise ParserError('Multiple files for a given year '
                                'found (specify a specific file in paramters)')
          elif len(eora_file_list) == 1:
              eora_loc = os.path.join(path, eora_file_list[0])
              is_zip = True
          else:
              # Just a path was given, no zip file found,
              # continue with only the path information - assumed an
              # unpacked zip file
              eora_loc = path
              is_zip = False
  
      meta_rec = MRIOMetaData(location=root_path)
  
      # Eora file specs
      eora_sep = '\t'
      ZY_col = namedtuple('ZY', 'full eora system name')(0, 1, 2, 3)
  
      eora_files = {
          'Z': 'Eora26_{year}_{price}_T.txt'.format(
              year=str(year), price=price),
          'Q': 'Eora26_{year}_{price}_Q.txt'.format(
              year=str(year), price=price),
          'QY': 'Eora26_{year}_{price}_QY.txt'.format(
              year=str(year), price=price),
          'VA': 'Eora26_{year}_{price}_VA.txt'.format(
              year=str(year), price=price),
          'Y': 'Eora26_{year}_{price}_FD.txt'.format(
              year=str(year), price=price),
          'labels_Z': 'labels_T.txt',
          'labels_Y': 'labels_FD.txt',
          'labels_Q': 'labels_Q.txt',
          'labels_VA': 'labels_VA.txt',
          }
  
      header = namedtuple('header', 'index columns index_names, column_names')
  
      eora_header_spec = {
          'Z': header(index='labels_Z',
                      columns='labels_Z',
                      index_names=IDX_NAMES['Z_row'],
                      column_names=IDX_NAMES['Z_col'],
                      ),
          'Q': header(index='labels_Q',
                      columns='labels_Z',
                      index_names=IDX_NAMES['F_row_src'],
                      column_names=IDX_NAMES['F_col']),
          'QY': header(index='labels_Q',
                       columns='labels_Y',
                       index_names=IDX_NAMES['F_row_src'],
                       column_names=IDX_NAMES['Y_col2'],
                       ),
          'VA': header(index='labels_VA',
                       columns='labels_Z',
                       index_names=IDX_NAMES['VA_row_unit_cat'],
                       column_names=IDX_NAMES['F_col']
                       ),
          'Y': header(index='labels_Z',
                      columns='labels_Y',
                      index_names=IDX_NAMES['Y_row'],
                      column_names=IDX_NAMES['Y_col2'],
                      ),
          }
  
      if is_zip:
          zip_file = zipfile.ZipFile(eora_loc)
          eora_data = {
              key: pd.read_table(
                  zip_file.open(filename),
                  sep=eora_sep,
                  header=None
                  ) for
              key, filename in eora_files.items()}
          zip_file.close()
      else:
          eora_data = {
              key: pd.read_table(
                  os.path.join(eora_loc, filename),
                  sep=eora_sep,
                  header=None
                  ) for
              key, filename in eora_files.items()}
      meta_rec._add_fileio(
          'Eora26 for {year}-{price} data parsed from {loc}'.format(
              year=year, price=price, loc=eora_loc))
  
      eora_data['labels_Z'] = eora_data[
          'labels_Z'].loc[:, [getattr(ZY_col, country_names), ZY_col.name]]
      eora_data['labels_Y'] = eora_data[
          'labels_Y'].loc[:, [getattr(ZY_col, country_names), ZY_col.name]]
      eora_data['labels_VA'] = eora_data[
          'labels_VA'].iloc[:, :len(eora_header_spec['VA'].column_names)]
      labQ = eora_data[
          'labels_Q'].iloc[:, :len(eora_header_spec['Q'].column_names)]
      labQ.columns = IDX_NAMES['F_row_src']
      Q_unit = labQ['stressor'].str.extract(r'\((.*)\)', expand=False)
      Q_unit.columns = IDX_NAMES['unit']
  
      labQ['stressor'] = labQ['stressor'].str.replace(r'\s\((.*)\)', '')
      eora_data['labels_Q'] = labQ
  
      for key in eora_header_spec.keys():
          eora_data[key].columns = (
              eora_data[eora_header_spec[key].columns].set_index(list(
                  eora_data[eora_header_spec[key].columns])).index)
          eora_data[key].columns.names = eora_header_spec[key].column_names
          eora_data[key].index = (
              eora_data[eora_header_spec[key].index].set_index(list(
                  eora_data[eora_header_spec[key].index])).index)
          eora_data[key].index.names = eora_header_spec[key].index_names
  
          try:
              meta_rec._add_modify(
                  'Remove Rest of the World ({name}) '
                  'row from {table} - loosing {amount}'.format(
                      name=row_name,
                      table=key,
                      amount=eora_data[key].loc[:, row_name].sum().values[0]))
              eora_data[key].drop(row_name, axis=1, inplace=True)
          except KeyError:
              pass
  
          try:
              meta_rec._add_modify(
                  'Remove Rest of the World ({name}) column '
                  'from {table} - loosing {amount}'.format(
                      name=row_name,
                      table=key,
                      amount=eora_data[key].loc[row_name, :].sum().values[0]))
              eora_data[key].drop(row_name, axis=0, inplace=True)
          except KeyError:
              pass
  
      Q_unit.index = eora_data['Q'].index
  
      meta_rec.note('Set Eora moneatry units to Mill USD manually')
      Z_unit = pd.DataFrame(data=['Mill USD'] * len(eora_data['Z'].index),
                            index=eora_data['Z'].index,
                            columns=['unit'])
      VA_unit = pd.DataFrame(data=['Mill USD'] * len(eora_data['VA'].index),
                             index=eora_data['VA'].index,
                             columns=['unit'])
  
      eora = IOSystem(
          Z=eora_data['Z'],
          Y=eora_data['Y'],
          unit=Z_unit,
          Q={
              'name': 'Q',
              'unit': Q_unit,
              'F': eora_data['Q'],
              'FY': eora_data['QY']
              },
          VA={
              'name': 'VA',
              'F': eora_data['VA'],
              'unit': VA_unit,
               },
          meta=meta_rec)
  
      return eora