docs: def parse_fields(self, response, fields_dict, net_start=None,
                       net_end=None, dt_format=None, field_list=None,
                       hourdelta=0, is_contact=False):
          """
          The function for parsing whois fields from a data input.
  
          Args:
              response (:obj:`str`): The response from the whois/rwhois server.
              fields_dict (:obj:`dict`): The mapping of fields to regex search
                  values (required).
              net_start (:obj:`int`): The starting point of the network (if
                  parsing multiple networks). Defaults to None.
              net_end (:obj:`int`): The ending point of the network (if parsing
                  multiple networks). Defaults to None.
              dt_format (:obj:`str`): The format of datetime fields if known.
                  Defaults to None.
              field_list (:obj:`list` of :obj:`str`): If provided, fields to
                  parse. Defaults to :obj:`ipwhois.nir.BASE_NET` if is_contact
                  is False. Otherwise, defaults to
                  :obj:`ipwhois.nir.BASE_CONTACT`.
              hourdelta (:obj:`int`): The timezone delta for created/updated
                  fields. Defaults to 0.
              is_contact (:obj:`bool`): If True, uses contact information
                  field parsing. Defaults to False.
  
          Returns:
              dict: A dictionary of fields provided in fields_dict, mapping to
                  the results of the regex searches.
          """
  
          response = '{0}\n'.format(response)
          if is_contact:
  
              ret = {}
  
              if not field_list:
  
                  field_list = list(BASE_CONTACT.keys())
  
          else:
  
              ret = {
                  'contacts': {'admin': None, 'tech': None},
                  'contact_admin': {},
                  'contact_tech': {}
              }
  
              if not field_list:
  
                  field_list = list(BASE_NET.keys())
                  field_list.remove('contacts')
                  field_list.append('contact_admin')
                  field_list.append('contact_tech')
  
          generate = ((field, pattern) for (field, pattern) in
                      fields_dict.items() if field in field_list)
  
          for field, pattern in generate:
  
              pattern = re.compile(
                  str(pattern),
                  re.DOTALL
              )
  
              if net_start is not None:
  
                  match = pattern.finditer(response, net_end, net_start)
  
              elif net_end is not None:
  
                  match = pattern.finditer(response, net_end)
  
              else:
  
                  match = pattern.finditer(response)
  
              values = []
              for m in match:
  
                  try:
  
                      values.append(m.group('val').strip())
  
                  except IndexError:
  
                      pass
  
              if len(values) > 0:
  
                  value = None
                  try:
  
                      if field in ['created', 'updated'] and dt_format:
  
                          value = (
                              datetime.strptime(
                                  values[0],
                                  str(dt_format)
                              ) - timedelta(hours=hourdelta)
                          ).isoformat('T')
  
                      elif field in ['nameservers']:
  
                          value = list(unique_everseen(values))
  
                      else:
  
                          values = unique_everseen(values)
                          value = '\n'.join(values)
  
                  except ValueError as e:
  
                      log.debug('NIR whois field parsing failed for {0}: {1}'
                                ''.format(field, e))
                      pass
  
                  ret[field] = value
  
          return ret