code: def get_index(self, as_dict=False, grouping_pattern=None):
          
  
          possible_dataframes = ['A', 'L', 'Z', 'Y', 'F', 'FY', 'M', 'S',
                                 'D_cba', 'D_pba',  'D_imp', 'D_exp',
                                 'D_cba_reg', 'D_pba_reg',
                                 'D_imp_reg', 'D_exp_reg',
                                 'D_cba_cap', 'D_pba_cap',
                                 'D_imp_cap', 'D_exp_cap', ]
          for df in possible_dataframes:
              if (df in self.__dict__) and (getattr(self, df) is not None):
                  orig_idx = getattr(self, df).index
                  break
          else:
              logging.warn("No attributes available to get index")
              return None
  
          if as_dict:
              dd = {k: k for k in orig_idx}
              if grouping_pattern:
                  for pattern, new_group in grouping_pattern.items():
                      if type(pattern) is str:
                          dd.update({k: new_group for k, v in dd.items() if
                                     re.match(pattern, k)})
                      else:
                          dd.update({k: new_group for k, v in dd.items() if
                                     all([re.match(pat, k[nr])
                                          for nr, pat in enumerate(pattern)])})
              return dd
  
          else:
              return orig_idx
docs: Returns the index of the DataFrames in the system
  
          Parameters
          ----------
          as_dict: boolean, optional
              If True, returns a 1:1 key-value matching for further processing
              prior to groupby functions. Otherwise (default) the index
              is returned as pandas index.
  
          grouping_pattern: dict, optional
              Dictionary with keys being regex patterns matching index and
              values the name for the grouping. If the index is a pandas
              multiindex, the keys must be tuples of length levels in the
              multiindex, with a valid regex expression at each position.
              Otherwise, the keys need to be strings.
              Only relevant if as_dict is True.