How to use the pywemo.discovery function in pywemo

def setup_platform(hass, config, add_entities, discovery_info=None):
    """Register discovered WeMo binary sensors."""

    if discovery_info is not None:
        location = discovery_info["ssdp_description"]
        mac = discovery_info["mac_address"]

        try:
            device = discovery.device_from_description(location, mac)
        except (
            requests.exceptions.ConnectionError,
            requests.exceptions.Timeout,
        ) as err:
            _LOGGER.error("Unable to access %s (%s)", location, err)
            raise PlatformNotReady

        if device:
            add_entities([WemoBinarySensor(hass, device)])

def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up discovered WeMo switches."""

    if discovery_info is not None:
        location = discovery_info["ssdp_description"]
        mac = discovery_info["mac_address"]

        try:
            device = discovery.device_from_description(location, mac)
        except (
            requests.exceptions.ConnectionError,
            requests.exceptions.Timeout,
        ) as err:
            _LOGGER.error("Unable to access %s (%s)", location, err)
            raise PlatformNotReady

        if device:
            add_entities([WemoSwitch(device)])

def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up discovered WeMo switches."""
    from pywemo import discovery

    if discovery_info is not None:
        location = discovery_info["ssdp_description"]
        mac = discovery_info["mac_address"]

        try:
            device = discovery.device_from_description(location, mac)
        except (
            requests.exceptions.ConnectionError,
            requests.exceptions.Timeout,
        ) as err:
            _LOGGER.error("Unable to access %s (%s)", location, err)
            raise PlatformNotReady

        if device.model_name == "Dimmer":
            add_entities([WemoDimmer(device)])
        else:
            setup_bridge(device, add_entities)

def discover_wemo_devices(now):
        """Run discovery for WeMo devices."""
        _LOGGER.debug("Beginning WeMo device discovery...")
        _LOGGER.debug("Adding statically configured WeMo devices...")
        for host, port in config.get(DOMAIN, {}).get(CONF_STATIC, []):
            url = setup_url_for_address(host, port)

            if not url:
                _LOGGER.error(
                    'Unable to get description url for WeMo at: %s',
                    '{}:{}'.format(host, port) if port else host)
                continue

            try:
                device = pywemo.discovery.device_from_description(url, None)
            except (requests.exceptions.ConnectionError,
                    requests.exceptions.Timeout) as err:
                _LOGGER.error('Unable to access WeMo at %s (%s)', url, err)
                continue

            if not [d[1] for d in devices
                    if d[1].serialnumber == device.serialnumber]:
                devices.append((url, device))

        if config.get(DOMAIN, {}).get(CONF_DISCOVERY):
            _LOGGER.debug("Scanning network for WeMo devices...")
            for device in pywemo.discover_devices():
                if not [d[1] for d in devices
                        if d[1].serialnumber == device.serialnumber]:
                    devices.append((setup_url_for_device(device),
                                    device))

def set_hardware_state(self, state, force = False):
    port = pywemo.ouimeaux_device.probe_wemo(self.get_address())
    device = pywemo.discovery.device_from_description(terrariumPowerSwitchWeMo.URL.format(self.get_address(), port), None)
    if state is terrariumPowerSwitch.ON:
      device.on()
    else:
      device.off()

def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up discovered WeMo switches."""
    from pywemo import discovery

    if discovery_info is not None:
        location = discovery_info['ssdp_description']
        mac = discovery_info['mac_address']

        try:
            device = discovery.device_from_description(location, mac)
        except (requests.exceptions.ConnectionError,
                requests.exceptions.Timeout) as err:
            _LOGGER.error('Unable to access %s (%s)', location, err)
            raise PlatformNotReady

        if device.model_name == 'Dimmer':
            add_entities([WemoDimmer(device)])
        else:
            setup_bridge(device, add_entities)

def discover_wemo_devices(now):
        """Run discovery for WeMo devices."""
        _LOGGER.debug("Beginning WeMo device discovery...")
        _LOGGER.debug("Adding statically configured WeMo devices...")
        for host, port in config.get(DOMAIN, {}).get(CONF_STATIC, []):
            url = setup_url_for_address(host, port)

            if not url:
                _LOGGER.error(
                    "Unable to get description url for WeMo at: %s",
                    f"{host}:{port}" if port else host,
                )
                continue

            try:
                device = pywemo.discovery.device_from_description(url, None)
            except (
                requests.exceptions.ConnectionError,
                requests.exceptions.Timeout,
            ) as err:
                _LOGGER.error("Unable to access WeMo at %s (%s)", url, err)
                continue

            if not [d[1] for d in devices if d[1].serialnumber == device.serialnumber]:
                devices.append((url, device))

        if config.get(DOMAIN, {}).get(CONF_DISCOVERY, DEFAULT_DISCOVERY):
            _LOGGER.debug("Scanning network for WeMo devices...")
            for device in pywemo.discover_devices():
                if not [
                    d[1] for d in devices if d[1].serialnumber == device.serialnumber
                ]:

def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up discovered WeMo humidifiers."""

    if DATA_KEY not in hass.data:
        hass.data[DATA_KEY] = {}

    if discovery_info is None:
        return

    location = discovery_info["ssdp_description"]
    mac = discovery_info["mac_address"]

    try:
        device = WemoHumidifier(discovery.device_from_description(location, mac))
    except (requests.exceptions.ConnectionError, requests.exceptions.Timeout) as err:
        _LOGGER.error("Unable to access %s (%s)", location, err)
        raise PlatformNotReady

    hass.data[DATA_KEY][device.entity_id] = device
    add_entities([device])

    def service_handle(service):
        """Handle the WeMo humidifier services."""
        entity_ids = service.data.get(ATTR_ENTITY_ID)

        humidifiers = [
            device
            for device in hass.data[DATA_KEY].values()
            if device.entity_id in entity_ids
        ]

def get_hardware_state(self):
    data = None
    try:
      port = pywemo.ouimeaux_device.probe_wemo(self.get_address())
      if port is not None:
        device = pywemo.discovery.device_from_description(terrariumPowerSwitchWeMo.URL.format(self.get_address(), port), None)
        data = device.get_state()

    except Exception as err:
      # Ignore for now
      print(err)

    return terrariumPowerSwitch.ON if terrariumUtils.is_true(data) else terrariumPowerSwitch.OFF

def setup_platform(hass, config, add_entities_callback, discovery_info=None):
    """Set up discovered WeMo switches."""
    from pywemo import discovery

    if discovery_info is not None:
        location = discovery_info['ssdp_description']
        mac = discovery_info['mac_address']

        try:
            device = discovery.device_from_description(location, mac)
        except (requests.exceptions.ConnectionError,
                requests.exceptions.Timeout) as err:
            _LOGGER.error('Unable to access %s (%s)', location, err)
            raise PlatformNotReady

        if device:
            add_entities_callback([WemoSwitch(device)])