docs: def parse_fields(self, response, fields_dict, net_start=None,
                       net_end=None, dt_format=None, field_list=None):
          """
          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:
  
                  ::
  
                      ['name', 'handle', 'description', 'country', 'state',
                      'city', 'address', 'postal_code', 'emails', 'created',
                      'updated']
  
          Returns:
              dict: A dictionary of fields provided in fields_dict, mapping to
                  the results of the regex searches.
          """
  
          ret = {}
  
          if not field_list:
  
              field_list = ['name', 'handle', 'description', 'country', 'state',
                            'city', 'address', 'postal_code', 'emails',
                            'created', 'updated']
  
          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 = []
              sub_section_end = None
              for m in match:
  
                  if sub_section_end:
  
                      if field not in (
                          'emails'
                      ) and (sub_section_end != (m.start() - 1)):
  
                          break
  
                  try:
  
                      values.append(m.group('val').strip())
  
                  except IndexError:
  
                      pass
  
                  sub_section_end = m.end()
  
              if len(values) > 0:
  
                  value = None
                  try:
  
                      if field == 'country':
  
                          value = values[0].upper()
  
                      elif field in ['created', 'updated'] and dt_format:
  
                          value = datetime.strptime(
                              values[0],
                              str(dt_format)).isoformat('T')
  
                      elif field in ['emails']:
  
                          value = list(unique_everseen(values))
  
                      else:
  
                          values = unique_everseen(values)
                          value = '\n'.join(values).strip()
  
                  except ValueError as e:
  
                      log.debug('Whois field parsing failed for {0}: {1}'.format(
                          field, e))
                      pass
  
                  ret[field] = value
  
          return ret