docs: def discoverParticularHost(host, service="ssdp:all", deviceDefinitionURL=None, timeout=1, retries=2,
                                 ipAddress="239.255.255.250", port=1900, proxies=None):
          """Discover a particular host and find the best response.
  
          This tries to find the most specific discovery result for the given host. Only the discovery result contains
          the URL to the XML tree which initializes the device definition. If an URL is already known it should be
          provided to avoid additional latency for a broader first device discovery.
          This method also do some magic to find the best result for the given host as UPnP devices behave sometimes
          strangely. This call is costly the result if any should be cached.
  
          :param str host: the host to find
          :param service: the service type or list of service types if known to search for
          :type service: str or list[str]
          :param str deviceDefinitionURL: if provided it is used to skip a first device discovery
          :param float timeout: the time to wait for each retry
          :param int retries: the amount of times how often the device is tried to discover
          :param str ipAddress: the multicast ip address to discover devices
          :param int port: the port to discover devices
          :param str proxies: proxy definition as defined here:
              `Proxy definition <http://docs.python-requests.org/en/latest/user/advanced/#proxies>`_
          :return: If the device have been found the response is returned otherwise None
          :rtype: DiscoveryResponse
          :raises ValueError: if problems with reading or parsing the xml device definition occurs
          :raises requests.exceptions.ConnectionError: when the device definitions can not be downloaded
          :raises requests.exceptions.ConnectTimeout: when download time out
  
          Example:
            ::
  
              proxies = {"http": "http://localhost:8888"}
              result = discoverParticularHost("192.168.0.1", proxies=proxies)
              if result is not None:
                  print("Host: " + result.locationHost + " Port: " + result.locationPort + " Device definitions: " + \\
                      result.location)
  
          .. seealso::
  
              :class:`~simpletr64.DiscoveryResponse`, :meth:`~simpletr64.Discover.discover`
          """
  
          # get all IP addresses for the given host
          ipResults = socket.getaddrinfo(host, 80)
  
          if len(ipResults) == 0:
              return None
  
          ipAddresses = []
  
          # remember all ip addresses for the given host
          for ipAdrTupple in ipResults:
              ipAddresses.append(ipAdrTupple[4][0])
  
          bestPick = None
          services = []
  
          if deviceDefinitionURL is None:
              # no xml definition given, so lets search for one
  
              # search for all devices first
              discoverResults = Discover.discover(service=service, timeout=timeout, retries=retries,
                                                  ipAddress=ipAddress, port=port)
  
              for result in discoverResults:
                  if result.locationHost in ipAddresses:
                      # now we found a result for that host, pick the best service type if multiple results for the host
                      # are found
                      if Discover.rateServiceTypeInResult(result) > Discover.rateServiceTypeInResult(bestPick):
                          bestPick = result
  
                      # remember all services
                      if result.service not in services:
                          services.append(result.service)
  
              if bestPick is None:
                  return None
          else:
              # create response with given parameter
              bestPick = DiscoveryResponse.create(deviceDefinitionURL, service=service)
  
          # some routers do not advice their TR64 capabilities but their UPnp which is only a subset of actions.
          # Try to find out if the given XML definition path will give us a better service type.
          # load xml definition
  
          # some devices response differently without a User-Agent
          headers = {"User-Agent": "Mozilla/5.0; SimpleTR64-3"}
  
          request = requests.get(bestPick.location, proxies=proxies, headers=headers, timeout=float(timeout))
  
          if request.status_code != 200:
              errorStr = DeviceTR64._extractErrorString(request)
              raise ValueError('Could not get CPE definitions for "' + bestPick.location + '": ' +
                               str(request.status_code) + ' - ' + request.reason + " -- " + errorStr)
  
          # parse xml
          try:
              root = ET.fromstring(request.text.encode('utf-8'))
          except Exception as e:
              raise ValueError("Could not parse CPE definitions for '" + bestPick.location + "': " + str(e))
  
          # find the first deviceType in the document tree
          for element in root.getiterator():
              # check if element tag name ends on deviceType, skip XML namespace
              if element.tag.lower().endswith("devicetype"):
  
                  serviceFound = element.text
  
                  # remember the service found if it does not exist yet
                  if serviceFound not in services:
                      services.append(serviceFound)
  
                  # create a specific service just to check if we found it already
                  serviceFound = serviceFound.replace("schemas-upnp-org", "dslforum-org")
  
                  # test if we already have the best service type then we dont need to do an other discovery request
                  if serviceFound == bestPick.service:
                      return bestPick
  
                  for service in services:
                      # we search for the specific device tyoe version as of specified in TR64 protocol.
                      # some devices returns different results depending on the given service type, so lets be
                      # very specific
                      specificService = service.replace("schemas-upnp-org", "dslforum-org")
  
                      if specificService not in services:
                          services.append(specificService)
  
                  # we do an other discovery request with more specific service/device type
                  discoverResultsSpecific = Discover.discover(service=services, timeout=float(timeout), retries=retries,
                                                              ipAddress=ipAddress, port=port)
  
                  # iterate through all results to find the most specific one
                  evenBetterPick = None
  
                  for specificResult in discoverResultsSpecific:
                      if specificResult.locationHost in ipAddresses:
                          if Discover.rateServiceTypeInResult(specificResult) > \
                                  Discover.rateServiceTypeInResult(evenBetterPick):
                              evenBetterPick = specificResult
  
                  if evenBetterPick is not None:
                      # best we could find
                      return evenBetterPick
  
                  # we found first deviceType tag in the XML structure, no need to go further
                  break
  
          if deviceDefinitionURL is not None:
              # we created our own response, so no result found
              return None
  
          # we found only an unspecific result, return it anyway
          return bestPick