docs: def match(list_a, list_b, not_found='not_found', enforce_sublist=False,
            country_data=COUNTRY_DATA_FILE, additional_data=None):
      """ Matches the country names given in two lists into a dictionary.
  
      This function matches names given in list_a to the one provided in list_b
      using regular expressions defined in country_data.
  
      Parameters
      ----------
      list_a : list
          Names of countries to identify
      list_b : list
          Master list of names for countries
  
      not_found : str, optional
          Fill in value for not found entries. If None, keep the input value
          (default: 'not found')
  
      enforce_sublist : boolean, optional
          If True, all entries in both list are list.
          If False(default), only multiple matches are list, rest are strings
  
      country_data : Pandas DataFrame or path to data file (optional)
          This is by default set to COUNTRY_DATA_FILE - the standard (tested)
          country list for coco.
  
      additional_data: (list of) Pandas DataFrames or data files (optional)
           Additional data to include for a specific analysis.
           This must be given in the same format as specified in the
           country_data file. (utf-8 encoded tab separated data, same
           column headers in all files)
  
      Returns
      -------
      dict:
          A dictionary with a key for every entry in list_a. The value
          correspond to the matching entry in list_b if found. If there is
          a 1:1 correspondence, the value is a str (if enforce_sublist is False),
          otherwise multiple entries as list.
  
      """
      if isinstance(list_a, str):
          list_a = [list_a]
      if isinstance(list_b, str):
          list_b = [list_b]
      if isinstance(list_a, tuple):
          list_a = list(list_a)
      if isinstance(list_b, tuple):
          list_b = list(list_b)
  
      coco = CountryConverter(country_data, additional_data)
  
      name_dict_a = dict()
      match_dict_a = dict()
  
      for name_a in list_a:
  
          name_dict_a[name_a] = []
          match_dict_a[name_a] = []
  
          for regex in coco.regexes:
              if regex.search(name_a):
                  match_dict_a[name_a].append(regex)
  
          if len(match_dict_a[name_a]) == 0:
              logging.warning('Could not identify {} in list_a'.format(name_a))
              _not_found_entry = name_a if not not_found else not_found
              name_dict_a[name_a].append(_not_found_entry)
              if not enforce_sublist:
                  name_dict_a[name_a] = name_dict_a[name_a][0]
              continue
  
          if len(match_dict_a[name_a]) > 1:
              logging.warning(
                  'Multiple matches for name {} in list_a'.format(name_a))
  
          for match_case in match_dict_a[name_a]:
              b_matches = 0
              for name_b in list_b:
                  if match_case.search(name_b):
                      b_matches += 1
                      name_dict_a[name_a].append(name_b)
  
          if b_matches == 0:
              logging.warning(
                  'Could not find any '
                  'correspondence for {} in list_b'.format(name_a))
              _not_found_entry = name_a if not not_found else not_found
              name_dict_a[name_a].append(_not_found_entry)
  
          if b_matches > 1:
              logging.warning('Multiple matches for '
                              'name {} in list_b'.format(name_a))
  
          if not enforce_sublist and (len(name_dict_a[name_a]) == 1):
              name_dict_a[name_a] = name_dict_a[name_a][0]
  
      return name_dict_a