docs: def lookup_rdap(self, inc_raw=False, retry_count=3, depth=0,
                      excluded_entities=None, bootstrap=False,
                      rate_limit_timeout=120, asn_alts=None, extra_org_map=None,
                      inc_nir=True, nir_field_list=None, asn_methods=None,
                      get_asn_description=True):
          """
          The function for retrieving and parsing whois information for an IP
          address via HTTP (RDAP).
  
          **This is now the recommended method, as RDAP contains much better
          information to parse.**
  
          Args:
              inc_raw (:obj:`bool`): Whether to include the raw whois results in
                  the returned dictionary. Defaults to False.
              retry_count (:obj:`int`): The number of times to retry in case
                  socket errors, timeouts, connection resets, etc. are
                  encountered. Defaults to 3.
              depth (:obj:`int`): How many levels deep to run queries when
                  additional referenced objects are found. Defaults to 0.
              excluded_entities (:obj:`list`): Entity handles to not perform
                  lookups. Defaults to None.
              bootstrap (:obj:`bool`): If True, performs lookups via ARIN
                  bootstrap rather than lookups based on ASN data. ASN lookups
                  are not performed and no output for any of the asn* fields is
                  provided. Defaults to False.
              rate_limit_timeout (:obj:`int`): The number of seconds to wait
                  before retrying when a rate limit notice is returned via
                  rdap+json. Defaults to 120.
              asn_alts (:obj:`list`): Additional lookup types to attempt if the
                  ASN dns lookup fails. Allow permutations must be enabled.
                  If None, defaults to all ['whois', 'http']. *WARNING*
                  deprecated in favor of new argument asn_methods.
              extra_org_map (:obj:`dict`): Dictionary mapping org handles to
                  RIRs. This is for limited cases where ARIN REST (ASN fallback
                  HTTP lookup) does not show an RIR as the org handle e.g., DNIC
                  (which is now the built in ORG_MAP) e.g., {'DNIC': 'arin'}.
                  Valid RIR values are (note the case-sensitive - this is meant
                  to match the REST result):
                  'ARIN', 'RIPE', 'apnic', 'lacnic', 'afrinic'
                  Defaults to None.
              inc_nir (:obj:`bool`): Whether to retrieve NIR (National Internet
                  Registry) information, if registry is JPNIC (Japan) or KRNIC
                  (Korea). If True, extra network requests will be required.
                  If False, the information returned for JP or KR IPs is
                  severely restricted. Defaults to True.
              nir_field_list (:obj:`list`): If provided and inc_nir, a list of
                  fields to parse:
                  ['name', 'handle', 'country', 'address', 'postal_code',
                  'nameservers', 'created', 'updated', 'contacts']
                  If None, defaults to all.
              asn_methods (:obj:`list`): ASN lookup types to attempt, in order.
                  If None, defaults to all ['dns', 'whois', 'http'].
              get_asn_description (:obj:`bool`): Whether to run an additional
                  query when pulling ASN information via dns, in order to get
                  the ASN description. Defaults to True.
  
          Returns:
              dict: The IP RDAP lookup results
  
              ::
  
                  {
                      'query' (str) - The IP address
                      'asn' (str) - The Autonomous System Number
                      'asn_date' (str) - The ASN Allocation date
                      'asn_registry' (str) - The assigned ASN registry
                      'asn_cidr' (str) - The assigned ASN CIDR
                      'asn_country_code' (str) - The assigned ASN country code
                      'asn_description' (str) - The ASN description
                      'entities' (list) - Entity handles referred by the top
                          level query.
                      'network' (dict) - Network information which consists of
                          the fields listed in the ipwhois.rdap._RDAPNetwork
                          dict.
                      'objects' (dict) - Mapping of entity handle->entity dict
                          which consists of the fields listed in the
                          ipwhois.rdap._RDAPEntity dict. The raw result is
                          included for each object if the inc_raw parameter
                          is True.
                      'raw' (dict) - Whois results in json format if the inc_raw
                          parameter is True.
                      'nir' (dict) - ipwhois.nir.NIRWhois results if inc_nir is
                          True.
                  }
          """
  
          from .rdap import RDAP
  
          # Create the return dictionary.
          results = {'nir': None}
  
          asn_data = None
          response = None
          if not bootstrap:
  
              # Retrieve the ASN information.
              log.debug('ASN lookup for {0}'.format(self.address_str))
              asn_data = self.ipasn.lookup(
                  inc_raw=inc_raw, retry_count=retry_count, asn_alts=asn_alts,
                  extra_org_map=extra_org_map, asn_methods=asn_methods,
                  get_asn_description=get_asn_description
              )
  
              # Add the ASN information to the return dictionary.
              results.update(asn_data)
  
          # Retrieve the RDAP data and parse.
          rdap = RDAP(self.net)
          log.debug('RDAP lookup for {0}'.format(self.address_str))
          rdap_data = rdap.lookup(
              inc_raw=inc_raw, retry_count=retry_count, asn_data=asn_data,
              depth=depth, excluded_entities=excluded_entities,
              response=response, bootstrap=bootstrap,
              rate_limit_timeout=rate_limit_timeout
          )
  
          # Add the RDAP information to the return dictionary.
          results.update(rdap_data)
  
          if inc_nir:
  
              nir = None
              if 'JP' == asn_data['asn_country_code']:
                  nir = 'jpnic'
              elif 'KR' == asn_data['asn_country_code']:
                  nir = 'krnic'
  
              if nir:
                  nir_whois = NIRWhois(self.net)
                  nir_data = nir_whois.lookup(
                      nir=nir, inc_raw=inc_raw, retry_count=retry_count,
                      response=None,
                      field_list=nir_field_list, is_offline=False
                  )
  
                  # Add the NIR information to the return dictionary.
                  results['nir'] = nir_data
  
          return results