docs: def concate_extension(*extensions, name):
      """ Concatenate extensions
  
      Notes
      ----
      The method assumes that the first index is the name of the
      stressor/impact/input type. To provide a consistent naming this is renamed
      to 'indicator' if they differ. All other index names ('compartments', ...)
      are added to the concatenated extensions and set to NaN for missing values.
  
      Notes
      ----
      Attributes which are not DataFrames will be set to None if they differ
      between the extensions
  
      Parameters
      ----------
  
      extensions : Extensions
          The Extensions to concatenate as multiple parameters
  
      name : string
          Name of the new extension
  
      Returns
      -------
  
      Concatenated extension
  
      """
      if type(extensions[0]) is tuple or type(extensions[0]) is list:
          extensions = extensions[0]
  
      # check if fd extensions is present in one of the given extensions
      FY_present = False
      SY_present = False
      SFY_columns = None
      for ext in extensions:
          if 'FY' in ext.get_DataFrame(data=False):
              FY_present = True
              SFY_columns = ext.FY.columns
          if 'SY' in ext.get_DataFrame(data=False):
              SY_present = True
              SFY_columns = ext.SY.columns
  
      # get the intersection of the available dataframes
      set_dfs = [set(ext.get_DataFrame(data=False)) for ext in extensions]
      df_dict = {key: None for key in set.intersection(*set_dfs)}
      if FY_present:
          df_dict['FY'] = None
      if SY_present:
          df_dict['SY'] = None
      empty_df_dict = df_dict.copy()
      attr_dict = {}
  
      # get data from each extension
      first_run = True
      for ext in extensions:
          # get corresponding attributes of all extensions
          for key in ext.__dict__:
              if type(ext.__dict__[key]) is not pd.DataFrame:
                  if attr_dict.get(key, -99) == -99:
                      attr_dict[key] = ext.__dict__[key]
                  elif attr_dict[key] == ext.__dict__[key]:
                      continue
                  else:
                      attr_dict[key] = None
  
          # get DataFrame data
          cur_dict = empty_df_dict.copy()
  
          for df in cur_dict:
              cur_dict[df] = getattr(ext, df)
  
          # add zero final demand extension if final demand extension present in
          # one extension
          if FY_present:
              # doesn't work with getattr b/c FY can be present as attribute but
              # not as DataFrame
              if 'FY' in ext.get_DataFrame(data=False):
                  cur_dict['FY'] = getattr(ext, 'FY')
              else:
                  cur_dict['FY'] = pd.DataFrame(data=0,
                                                index=ext.get_index(),
                                                columns=SFY_columns)
          if SY_present:
              # doesn't work with getattr b/c SY can be present as attribute but
              # not as DataFrame
              if 'SY' in ext.get_DataFrame(data=False):
                  cur_dict['SY'] = getattr(ext, 'SY')
              else:
                  cur_dict['SY'] = pd.DataFrame(data=0,
                                                index=ext.get_index(),
                                                columns=SFY_columns)
  
          # append all df data
          for key in cur_dict:
              if not first_run:
                  if cur_dict[key].index.names != df_dict[key].index.names:
                      cur_ind_names = list(cur_dict[key].index.names)
                      df_ind_names = list(df_dict[key].index.names)
                      cur_ind_names[0] = 'indicator'
                      df_ind_names[0] = cur_ind_names[0]
                      cur_dict[key].index.set_names(cur_ind_names,
                                                    inplace=True)
                      df_dict[key].index.set_names(df_ind_names,
                                                   inplace=True)
  
                      for ind in cur_ind_names:
                          if ind not in df_ind_names:
                              df_dict[key] = (df_dict[key].
                                              set_index(pd.DataFrame(
                                                  data=None,
                                                  index=df_dict[key].index,
                                                  columns=[ind])[ind],
                                                  append=True))
                      for ind in df_ind_names:
                          if ind not in cur_ind_names:
                              cur_dict[key] = (cur_dict[key].set_index(
                                                  pd.DataFrame(
                                                      data=None,
                                                      index=cur_dict[key].index,
                                                      columns=[ind])
                                                  [ind], append=True))
  
              df_dict[key] = pd.concat([df_dict[key], cur_dict[key]])
  
          first_run = False
  
          all_dict = dict(list(attr_dict.items()) + list(df_dict.items()))
          all_dict['name'] = name
  
      return Extension(**all_dict)