docs: def parse_exiobase2(path, charact=True, popvector='exio2'):
      """ Parse the exiobase 2.2.2 source files for the IOSystem
  
      The function parse product by product and industry by industry source file
      in the coefficient form (A and S).
  
      Filenames are hardcoded in the parser - for any other function the code has
      to be adopted. Check git comments to find older verions.
  
      Parameters
      ----------
      path : string or pathlib.Path
          Path to the EXIOBASE source files
      charact : string or boolean, optional
          Filename with path to the characterisation matrices for the extensions
          (xls). This is provided together with the EXIOBASE system and given as
          a xls file. The four sheets  Q_factorinputs, Q_emission, Q_materials
          and Q_resources are read and used to generate one new extensions with
          the impacts.
          If set to True, the characterisation file found in path is used (
          can be in the zip or extracted). If a string, it is assumed that
          it points to valid characterisation file. If False or None, no
          characterisation file will be used.
      popvector : string or pd.DataFrame, optional
          The population vector for the countries.  This can be given as
          pd.DataFrame(index = population, columns = countrynames) or, (default)
          will be taken from the pymrio module. If popvector = None no population
          data will be passed to the IOSystem.
  
      Returns
      -------
      IOSystem
          A IOSystem with the parsed exiobase 2 data
  
      Raises
      ------
      ParserError
          If the exiobase source files are not complete in the given path
  
      """
      path = os.path.abspath(os.path.normpath(str(path)))
  
      exio_files = get_exiobase_files(path)
      if len(exio_files) == 0:
          raise ParserError("No EXIOBASE files found at {}".format(path))
  
      system = _get_MRIO_system(path)
      if not system:
          logging.warning("Could not determine system (pxp or ixi)"
                          " set system parameter manually")
  
      io = generic_exiobase12_parser(exio_files, system=system)
  
      # read the characterisation matrices if available
      # and build one extension with the impacts
      if charact:
          logging.debug('Parse characterisation matrix')
          # dict with correspondence to the extensions
          Qsheets = {'Q_factorinputs': 'factor_inputs',
                     'Q_emission': 'emissions',
                     'Q_materials': 'materials',
                     'Q_resources': 'resources'}
  
          Q_head_col = dict()
          Q_head_row = dict()
          Q_head_col_rowname = dict()
          Q_head_col_rowunit = dict()
          # Q_head_col_metadata = dict()
          # number of cols containing row headers at the beginning
          Q_head_col['Q_emission'] = 4
          # number of rows containing col headers at the top - this will be
          # skipped
          Q_head_row['Q_emission'] = 3
          # assuming the same classification as in the extensions
          Q_head_col['Q_factorinputs'] = 2
          Q_head_row['Q_factorinputs'] = 2
          Q_head_col['Q_resources'] = 2
          Q_head_row['Q_resources'] = 3
          Q_head_col['Q_materials'] = 2
          Q_head_row['Q_materials'] = 2
  
          #  column to use as name for the rows
          Q_head_col_rowname['Q_emission'] = 1
          Q_head_col_rowname['Q_factorinputs'] = 0
          Q_head_col_rowname['Q_resources'] = 0
          Q_head_col_rowname['Q_materials'] = 0
  
          # column to use as unit for the rows which gives also the last column
          # before the data
          Q_head_col_rowunit['Q_emission'] = 3
          Q_head_col_rowunit['Q_factorinputs'] = 1
          Q_head_col_rowunit['Q_resources'] = 1
          Q_head_col_rowunit['Q_materials'] = 1
  
          if charact is str:
              charac_data = {Qname: pd.read_excel(
                             charact,
                             sheet_name=Qname,
                             skiprows=list(range(0, Q_head_row[Qname])),
                             header=None)
                             for Qname in Qsheets}
          else:
              _content = get_repo_content(path)
              charac_regex = re.compile('(?<!\_)(?<!\.)characterisation.*xlsx')
              charac_files = [ff for ff in _content.filelist if
                              re.search(charac_regex, ff)]
              if len(charac_files) > 1:
                  raise ParserError(
                      "Found multiple characcterisation files "
                      "in {} - specify one: {}".format(path, charac_files))
              elif len(charac_files) == 0:
                  raise ParserError(
                      "No characcterisation file found "
                      "in {}".format(path))
              else:
                  if _content.iszip:
                      with zipfile.ZipFile(path, 'r') as zz:
                          charac_data = {Qname: pd.read_excel(
                                         zz.open(charac_files[0]),
                                         sheet_name=Qname,
                                         skiprows=list(
                                             range(0, Q_head_row[Qname])),
                                         header=None)
                                         for Qname in Qsheets}
  
                  else:
                      charac_data = {Qname: pd.read_excel(
                                     os.path.join(path, charac_files[0]),
                                     sheet_name=Qname,
                                     skiprows=list(range(0, Q_head_row[Qname])),
                                     header=None)
                                     for Qname in Qsheets}
  
          _unit = dict()
          # temp for the calculated impacts which than
          # get summarized in the 'impact'
          _impact = dict()
          impact = dict()
          for Qname in Qsheets:
              # unfortunately the names in Q_emissions are
              # not completely unique - fix that
              if Qname is 'Q_emission':
                  _index = charac_data[Qname][Q_head_col_rowname[Qname]].copy()
                  _index.iloc[42] = _index.iloc[42] + ' 2008'
                  _index.iloc[43] = _index.iloc[43] + ' 2008'
                  _index.iloc[44] = _index.iloc[44] + ' 2010'
                  _index.iloc[45] = _index.iloc[45] + ' 2010'
                  charac_data[Qname][Q_head_col_rowname[Qname]] = _index
  
              charac_data[Qname].index = (
                  charac_data[Qname][Q_head_col_rowname[Qname]])
  
              _unit[Qname] = pd.DataFrame(
                      charac_data[Qname].iloc[:, Q_head_col_rowunit[Qname]])
              _unit[Qname].columns = ['unit']
              _unit[Qname].index.name = 'impact'
              charac_data[Qname] = charac_data[Qname].ix[
                  :, Q_head_col_rowunit[Qname]+1:]
              charac_data[Qname].index.name = 'impact'
  
              try:
                  _FY = io.__dict__[Qsheets[Qname]].FY.values
              except AttributeError:
                  _FY = np.zeros([io.__dict__[Qsheets[Qname]].S.shape[0],
                                  io.Y.shape[1]])
  
              _impact[Qname] = {'S': charac_data[Qname].dot(
                                     io.__dict__[Qsheets[Qname]].S.values),
                                'FY': charac_data[Qname].dot(_FY),
                                'unit': _unit[Qname]
                                }
  
          impact['S'] = (_impact['Q_factorinputs']['S']
                         .append(_impact['Q_emission']['S'])
                         .append(_impact['Q_materials']['S'])
                         .append(_impact['Q_resources']['S']))
          impact['FY'] = (_impact['Q_factorinputs']['FY']
                          .append(_impact['Q_emission']['FY'])
                          .append(_impact['Q_materials']['FY'])
                          .append(_impact['Q_resources']['FY']))
          impact['S'].columns = io.emissions.S.columns
          impact['FY'].columns = io.emissions.FY.columns
          impact['unit'] = (_impact['Q_factorinputs']['unit']
                            .append(_impact['Q_emission']['unit'])
                            .append(_impact['Q_materials']['unit'])
                            .append(_impact['Q_resources']['unit']))
          impact['name'] = 'impact'
          io.impact = Extension(**impact)
  
      if popvector is 'exio2':
          logging.debug('Read population vector')
          io.population = pd.read_table(os.path.join(PYMRIO_PATH['exio20'],
                                                     './misc/population.txt'),
                                        index_col=0).astype(float)
      else:
          io.population = popvector
  
      return io