denonavr 0.11.2__py3-none-any.whl → 0.11.6__py3-none-any.whl

denonavr/input.py

@@ -8,13 +8,14 @@ This module implements the handler for input functions of Denon AVR receivers.
 """
 
 import asyncio
-import html
 import logging
+from collections.abc import Hashable
 from copy import deepcopy
-from typing import Dict, Hashable, List, Optional, Tuple
+from typing import Dict, List, Optional, Set, Tuple
 
 import attr
 import httpx
+from ftfy import fix_text
 
 from .appcommand import AppCommands
 from .const import (
@@ -56,15 +57,15 @@ def lower_string(value: Optional[str]) -> Optional[str]:
     return str(value).lower()
 
 
-def unescape_string(value: Optional[str]) -> Optional[str]:
-    """Perform HTML unescape on value."""
+def fix_string(value: Optional[str]) -> Optional[str]:
+    """Fix errors in string like unescaped HTML and wrong utf-8 encoding."""
     if value is None:
         return value
-    return html.unescape(str(value))
+    return fix_text(str(value)).strip()
 
 
 def set_input_func(
-    instance: DenonAVRFoundation, attribute: attr.Attribute, value: str
+    instance: "DenonAVRInput", attribute: attr.Attribute, value: str
 ) -> str:
     """Set input_func after mapping from input_func_map."""
     # pylint: disable=protected-access
@@ -75,8 +76,11 @@ def set_input_func(
     # AirPlay and Internet Radio are not always listed in available sources
     if value in ["AirPlay", "Internet Radio"]:
         if value not in instance._input_func_map:
+            instance._additional_input_funcs.add(value)
             instance._input_func_map[value] = value
             instance._input_func_map_rev[value] = value
+            instance._netaudio_func_list.append(value)
+            instance._playing_func_list.append(value)
     try:
         input_func = instance._input_func_map_rev[value]
     except KeyError:
@@ -121,6 +125,12 @@ class DenonAVRInput(DenonAVRFoundation):
         ),
         default=attr.Factory(list),
     )
+    _additional_input_funcs: Set[str] = attr.ib(
+        validator=attr.validators.deep_iterable(
+            attr.validators.instance_of(str), attr.validators.instance_of(set)
+        ),
+        default=attr.Factory(set),
+    )
     _media_update_handle: asyncio.TimerHandle = attr.ib(default=None)
     _input_func_update_lock: asyncio.Lock = attr.ib(default=attr.Factory(asyncio.Lock))
 
@@ -134,22 +144,22 @@ class DenonAVRInput(DenonAVRFoundation):
     )
 
     _artist: Optional[str] = attr.ib(
-        converter=attr.converters.optional(unescape_string), default=None
+        converter=attr.converters.optional(fix_string), default=None
     )
     _album: Optional[str] = attr.ib(
-        converter=attr.converters.optional(unescape_string), default=None
+        converter=attr.converters.optional(fix_string), default=None
     )
     _band: Optional[str] = attr.ib(
-        converter=attr.converters.optional(unescape_string), default=None
+        converter=attr.converters.optional(fix_string), default=None
     )
     _title: Optional[str] = attr.ib(
-        converter=attr.converters.optional(unescape_string), default=None
+        converter=attr.converters.optional(fix_string), default=None
     )
     _frequency: Optional[str] = attr.ib(
-        converter=attr.converters.optional(unescape_string), default=None
+        converter=attr.converters.optional(fix_string), default=None
     )
     _station: Optional[str] = attr.ib(
-        converter=attr.converters.optional(unescape_string), default=None
+        converter=attr.converters.optional(fix_string), default=None
     )
     _image_url: Optional[str] = attr.ib(
         converter=attr.converters.optional(str), default=None
@@ -175,9 +185,16 @@ class DenonAVRInput(DenonAVRFoundation):
         for tag in self.appcommand_attrs:
             self._device.api.add_appcommand_update_tag(tag)
 
+        power_event = "ZM"
+        if self._device.zone == ZONE2:
+            power_event = "Z2"
+        elif self._device.zone == ZONE3:
+            power_event = "Z3"
+        self._device.telnet_api.register_callback(
+            power_event, self._async_power_callback
+        )
         self._device.telnet_api.register_callback("SI", self._async_input_callback)
-        self._device.telnet_api.register_callback("PW", self._async_power_callback)
-        self._device.telnet_api.register_callback("NS", self._async_netaudio_callback)
+        self._device.telnet_api.register_callback("NSE", self._async_netaudio_callback)
         self._device.telnet_api.register_callback("TF", self._async_tuner_callback)
         self._device.telnet_api.register_callback("HD", self._async_hdtuner_callback)
         self._device.telnet_api.register_callback(
@@ -198,7 +215,7 @@ class DenonAVRInput(DenonAVRFoundation):
         if self._device.power != POWER_ON:
             return
 
-        if self._schedule_media_updates() is True:
+        if self._schedule_media_updates():
             self._state = STATE_PLAYING
         else:
             self._unset_media_state()
@@ -215,7 +232,7 @@ class DenonAVRInput(DenonAVRFoundation):
             self._stop_media_update()
             self._unset_media_state()
             self._state = STATE_OFF
-        elif self._schedule_media_updates() is True:
+        elif self._schedule_media_updates():
             self._state = STATE_PLAYING
         else:
             self._unset_media_state()
@@ -255,8 +272,11 @@ class DenonAVRInput(DenonAVRFoundation):
 
     def _update_netaudio(self) -> None:
         """Update netaudio information."""
-        self._device.telnet_api.send_commands("NSE")
-        self._schedule_netaudio_update()
+        if self._device.telnet_available:
+            self._device.telnet_api.send_commands("NSE")
+            self._schedule_netaudio_update()
+        else:
+            self._stop_media_update()
 
     async def _async_netaudio_callback(
         self, zone: str, event: str, parameter: str
@@ -267,12 +287,12 @@ class DenonAVRInput(DenonAVRFoundation):
         if self._input_func not in self._netaudio_func_list:
             return
 
-        if parameter.startswith("E1"):
-            self._title = parameter[2:].strip()
-        elif parameter.startswith("E2"):
-            self._artist = parameter[2:].strip()
-        elif parameter.startswith("E4"):
-            self._album = parameter[2:].strip()
+        if parameter.startswith("1"):
+            self._title = parameter[1:]
+        elif parameter.startswith("2"):
+            self._artist = parameter[1:]
+        elif parameter.startswith("4"):
+            self._album = parameter[1:]
         self._band = None
         self._frequency = None
         self._station = None
@@ -283,7 +303,7 @@ class DenonAVRInput(DenonAVRFoundation):
             port=self._device.api.port,
             hash=hash((self._title, self._artist, self._album)),
         )
-        await self._async_test_image_accessable()
+        await self._async_test_image_accessible()
 
     def _schedule_tuner_update(self) -> None:
         """Schedule a tuner update task."""
@@ -295,8 +315,11 @@ class DenonAVRInput(DenonAVRFoundation):
 
     def _update_tuner(self) -> None:
         """Update tuner information."""
-        self._device.telnet_api.send_commands("TFAN?", "TFANNAME?")
-        self._schedule_tuner_update()
+        if self._device.telnet_available:
+            self._device.telnet_api.send_commands("TFAN?", "TFANNAME?")
+            self._schedule_tuner_update()
+        else:
+            self._stop_media_update()
 
     async def _async_tuner_callback(
         self, zone: str, event: str, parameter: str
@@ -308,9 +331,9 @@ class DenonAVRInput(DenonAVRFoundation):
             return
 
         if parameter.startswith("ANNAME"):
-            self._station = parameter[6:].strip()
+            self._station = parameter[6:]
         elif len(parameter) == 8:
-            self._frequency = "{}.{}".format(parameter[2:6], parameter[6:]).strip("0")
+            self._frequency = f"{parameter[2:6]}.{parameter[6:]}".strip("0")
             if parameter[2:] > "050000":
                 self._band = "AM"
             else:
@@ -324,7 +347,7 @@ class DenonAVRInput(DenonAVRFoundation):
         self._image_url = STATIC_ALBUM_URL.format(
             host=self._device.api.host, port=self._device.api.port
         )
-        await self._async_test_image_accessable()
+        await self._async_test_image_accessible()
 
     def _schedule_hdtuner_update(self) -> None:
         """Schedule a HD tuner update task."""
@@ -336,8 +359,11 @@ class DenonAVRInput(DenonAVRFoundation):
 
     def _update_hdtuner(self) -> None:
         """Update HD tuner information."""
-        self._device.telnet_api.send_commands("HD?")
-        self._schedule_hdtuner_update()
+        if self._device.telnet_available:
+            self._device.telnet_api.send_commands("HD?")
+            self._schedule_hdtuner_update()
+        else:
+            self._stop_media_update()
 
     async def _async_hdtuner_callback(
         self, zone: str, event: str, parameter: str
@@ -349,13 +375,13 @@ class DenonAVRInput(DenonAVRFoundation):
             return
 
         if parameter.startswith("ARTIST"):
-            self._artist = parameter[6:].strip()
+            self._artist = parameter[6:]
         elif parameter.startswith("TITLE"):
-            self._title = parameter[5:].strip()
+            self._title = parameter[5:]
         elif parameter.startswith("ALBUM"):
-            self._album = parameter[5:].strip()
+            self._album = parameter[5:]
         elif parameter.startswith("ST NAME"):
-            self._station = parameter[7:].strip()
+            self._station = parameter[7:]
 
         self._band = None
         self._frequency = None
@@ -364,13 +390,13 @@ class DenonAVRInput(DenonAVRFoundation):
         self._image_url = STATIC_ALBUM_URL.format(
             host=self._device.api.host, port=self._device.api.port
         )
-        await self._async_test_image_accessable()
+        await self._async_test_image_accessible()
 
     async def _async_input_func_update_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle input func update events."""
-        if self._input_func_update_lock.locked() is True:
+        if self._input_func_update_lock.locked():
             return
         async with self._input_func_update_lock:
             await self.async_update_inputfuncs()
@@ -380,7 +406,7 @@ class DenonAVRInput(DenonAVRFoundation):
     ) -> None:
         """Update input functions asynchronously."""
         # Ensure instance is setup before updating
-        if self._is_setup is False:
+        if not self._is_setup:
             self.setup()
 
         # Update input functions
@@ -425,9 +451,9 @@ class DenonAVRInput(DenonAVRFoundation):
                 # Get list of all input sources of receiver
                 xml_list = xml_zonecapa.find("./InputSource/List")
                 for xml_source in xml_list.findall("Source"):
-                    receiver_sources[
-                        xml_source.find("FuncName").text
-                    ] = xml_source.find("DefaultName").text
+                    receiver_sources[xml_source.find("FuncName").text] = (
+                        xml_source.find("DefaultName").text
+                    )
 
         return receiver_sources
 
@@ -462,9 +488,8 @@ class DenonAVRInput(DenonAVRFoundation):
             raise
 
         for child in xml.findall(
-            "./cmd[@{attribute}='{cmd}']/functionrename/list".format(
-                attribute=APPCOMMAND_CMD_TEXT, cmd=AppCommands.GetRenameSource.cmd_text
-            )
+            f"./cmd[@{APPCOMMAND_CMD_TEXT}='{AppCommands.GetRenameSource.cmd_text}']"
+            "/functionrename/list"
         ):
             try:
                 renamed_sources[child.find("name").text.strip()] = child.find(
@@ -474,9 +499,8 @@ class DenonAVRInput(DenonAVRFoundation):
                 continue
 
         for child in xml.findall(
-            "./cmd[@{attribute}='{cmd}']/functiondelete/list".format(
-                attribute=APPCOMMAND_CMD_TEXT, cmd=AppCommands.GetDeletedSource.cmd_text
-            )
+            f"./cmd[@{APPCOMMAND_CMD_TEXT}='{AppCommands.GetDeletedSource.cmd_text}']"
+            "/functiondelete/list"
         ):
             try:
                 deleted_sources[child.find("FuncName").text.strip()] = (
@@ -519,9 +543,8 @@ class DenonAVRInput(DenonAVRFoundation):
                 )
             else:
                 raise AvrProcessingError(
-                    "Method does not work for receiver type {}".format(
-                        self._device.receiver.type
-                    )
+                    "Method does not work for receiver type"
+                    f" {self._device.receiver.type}"
                 )
         except AvrRequestError as err:
             _LOGGER.debug("Error when getting changed sources", exc_info=err)
@@ -608,9 +631,13 @@ class DenonAVRInput(DenonAVRFoundation):
                 "Receiver sources list empty. Please check if device is powered on."
             )
 
+        # Add additional input functions discovered at run-time
+        for function in self._additional_input_funcs:
+            receiver_sources[function] = function
+
         # Get renamed and deleted sources
         # From Appcommand.xml if supported
-        if self._device.use_avr_2016_update is True:
+        if self._device.use_avr_2016_update:
             (
                 renamed_sources,
                 deleted_sources,
@@ -630,7 +657,7 @@ class DenonAVRInput(DenonAVRFoundation):
                 receiver_sources[key] = value
 
         # Remove all deleted sources
-        if self._show_all_inputs is False:
+        if not self._show_all_inputs:
             for deleted_source in deleted_sources.items():
                 if deleted_source[1] == "DEL":
                     receiver_sources.pop(deleted_source[0], None)
@@ -642,7 +669,7 @@ class DenonAVRInput(DenonAVRFoundation):
         playing_func_list = []
 
         for item in receiver_sources.items():
-            # Mapping of item[0] because some func names are inconsistant
+            # Mapping of item[0] because some func names are inconsistent
             # at AVR-X receivers
 
             m_item_0 = SOURCE_MAPPING.get(item[0], item[0])
@@ -689,8 +716,12 @@ class DenonAVRInput(DenonAVRFoundation):
             deleted_sources,
         ) = await self.async_get_changed_sources_status_xml(cache_id=cache_id)
 
+        # Add additional input functions discovered at run-time
+        for function in self._additional_input_funcs:
+            receiver_sources[function] = function
+
         # Remove all deleted sources
-        if self._show_all_inputs is False:
+        if not self._show_all_inputs:
             for deleted_source in deleted_sources.items():
                 if deleted_source[1] == "DEL":
                     receiver_sources.pop(deleted_source[0], None)
@@ -719,21 +750,22 @@ class DenonAVRInput(DenonAVRFoundation):
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ):
         """Update state of device."""
-        if self._device.use_avr_2016_update is True:
+        if self._device.use_avr_2016_update is None:
+            raise AvrProcessingError(
+                "Device is not setup correctly, update method not set"
+            )
+
+        if self._device.use_avr_2016_update:
             await self.async_update_attrs_appcommand(
                 self.appcommand_attrs, global_update=global_update, cache_id=cache_id
             )
-        elif self._device.use_avr_2016_update is False:
+        else:
             urls = [self._device.urls.status]
             if self._device.zone == MAIN_ZONE:
                 urls.append(self._device.urls.mainzone)
             await self.async_update_attrs_status_xml(
                 self.status_xml_attrs, urls, cache_id=cache_id
             )
-        else:
-            raise AvrProcessingError(
-                "Device is not setup correctly, update method not set"
-            )
 
     async def async_update_media_state(self, cache_id: Optional[Hashable] = None):
         """Update media state of device."""
@@ -815,10 +847,10 @@ class DenonAVRInput(DenonAVRFoundation):
             # On track change assume device is PLAYING
             self._state = STATE_PLAYING
 
-        await self._async_test_image_accessable()
+        await self._async_test_image_accessible()
 
-    async def _async_test_image_accessable(self) -> None:
-        """Test if image URL is accessable."""
+    async def _async_test_image_accessible(self) -> None:
+        """Test if image URL is accessible."""
         if self._image_available is None and self._image_url is not None:
             client = self._device.api.async_client_getter()
             try:
@@ -842,7 +874,7 @@ class DenonAVRInput(DenonAVRFoundation):
                 if self._device.api.is_default_async_client():
                     await client.aclose()
         # Already tested that image URL is not accessible
-        elif self._image_available is False:
+        elif not self._image_available:
             self._image_url = None
 
     def _unset_media_state(self) -> None:
@@ -959,20 +991,24 @@ class DenonAVRInput(DenonAVRFoundation):
                 direct_mapping = False
         # AVR-nonX receiver and if no mapping was found get parameter for
         # setting input_func directly
-        if direct_mapping is True:
+        if direct_mapping:
             try:
                 linp = self._input_func_map[input_func]
             except KeyError as err:
                 raise AvrCommandError(
-                    "No mapping for input source {}".format(input_func)
+                    f"No mapping for input source {input_func}"
                 ) from err
         # Create command URL and send command via HTTP GET
         if linp in self._favorite_func_list:
             command_url = self._device.urls.command_fav_src + linp
+            telnet_command = self._device.telnet_commands.command_fav_src + linp
         else:
             command_url = self._device.urls.command_sel_src + linp
-
-        await self._device.api.async_get_command(command_url)
+            telnet_command = self._device.telnet_commands.command_sel_src + linp
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(telnet_command)
+        else:
+            await self._device.api.async_get_command(command_url)
 
     async def async_toggle_play_pause(self) -> None:
         """Toggle play pause media player."""
@@ -993,15 +1029,26 @@ class DenonAVRInput(DenonAVRFoundation):
             if self._state == STATE_PLAYING:
                 _LOGGER.info("Already playing, play command not sent")
                 return
-
-            await self._device.api.async_get_command(self._device.urls.command_play)
+            if self._device.telnet_available:
+                await self._device.telnet_api.async_send_commands(
+                    self._device.telnet_commands.command_play
+                )
+            else:
+                await self._device.api.async_get_command(self._device.urls.command_play)
             self._state = STATE_PLAYING
 
     async def async_pause(self) -> None:
         """Send pause command to receiver command via HTTP post."""
         # Use pause command only for sources which support NETAUDIO
         if self._input_func in self._netaudio_func_list:
-            await self._device.api.async_get_command(self._device.urls.command_pause)
+            if self._device.telnet_available:
+                await self._device.telnet_api.async_send_commands(
+                    self._device.telnet_commands.command_play
+                )
+            else:
+                await self._device.api.async_get_command(
+                    self._device.urls.command_pause
+                )
             self._state = STATE_PAUSED
 
     async def async_previous_track(self) -> None:

denonavr/soundmode.py

@@ -9,8 +9,9 @@ This module implements the handler for sound mode of Denon AVR receivers.
 
 import asyncio
 import logging
+from collections.abc import Hashable
 from copy import deepcopy
-from typing import Dict, Hashable, List, Optional
+from typing import Dict, List, Optional
 
 import attr
 
@@ -22,7 +23,7 @@ from .const import (
     DENON_ATTR_SETATTR,
     SOUND_MODE_MAPPING,
 )
-from .exceptions import AvrProcessingError
+from .exceptions import AvrCommandError, AvrProcessingError
 from .foundation import DenonAVRFoundation
 
 _LOGGER = logging.getLogger(__name__)
@@ -43,7 +44,7 @@ def sound_mode_map_factory() -> Dict[str, List]:
     return sound_mode_map
 
 
-def sound_mode_rev_map_factory(instance: DenonAVRFoundation) -> Dict[str, str]:
+def sound_mode_rev_map_factory(instance: "DenonAVRSoundMode") -> Dict[str, str]:
     """
     Construct the sound_mode_rev_map.
 
@@ -109,7 +110,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
                 self._device.api.add_appcommand_update_tag(tag)
 
             # Soundmode is always available for AVR-X and AVR-X-2016 receivers
-            # For AVR receiver it will be tested druing the first update
+            # For AVR receiver it will be tested during the first update
             if self._device.receiver in [AVR_X, AVR_X_2016]:
                 self._support_sound_mode = True
             else:
@@ -135,7 +136,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
     ) -> None:
         """Update sound mode asynchronously."""
         # Ensure instance is setup before updating
-        if self._is_setup is False:
+        if not self._is_setup:
             await self.async_setup()
 
         # Update state
@@ -147,13 +148,18 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ):
         """Update sound mode status of device."""
-        if self._device.use_avr_2016_update is True:
+        if self._device.use_avr_2016_update is None:
+            raise AvrProcessingError(
+                "Device is not setup correctly, update method not set"
+            )
+
+        if self._device.use_avr_2016_update:
             await self.async_update_attrs_appcommand(
                 self.appcommand_attrs, global_update=global_update, cache_id=cache_id
             )
-        elif self._device.use_avr_2016_update is False:
+        else:
             urls = [self._device.urls.status, self._device.urls.mainzone]
-            if self._support_sound_mode is False:
+            if self._is_setup and not self._support_sound_mode:
                 return
             # There are two different options of sound mode tags
             try:
@@ -170,10 +176,6 @@ class DenonAVRSoundMode(DenonAVRFoundation):
                     self._support_sound_mode = False
                     return
             self._support_sound_mode = True
-        else:
-            raise AvrProcessingError(
-                "Device is not setup correctly, update method not set"
-            )
 
     def match_sound_mode(self) -> Optional[str]:
         """Match the raw_sound_mode to its corresponding sound_mode."""
@@ -229,12 +231,17 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         Calls command to activate/deactivate the mode
         """
         command_url = self._device.urls.command_set_all_zone_stereo
+        telnet_command = self._device.telnet_commands.command_set_all_zone_stereo
         if zst_on:
             command_url += "ZST ON"
+            telnet_command += "ZST ON"
         else:
             command_url += "ZST OFF"
-
-        await self._device.api.async_get_command(command_url)
+            telnet_command += "ZST OFF"
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(telnet_command)
+        else:
+            await self._device.api.async_get_command(command_url)
 
     ##############
     # Properties #
@@ -251,7 +258,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         return sound_mode_matched
 
     @property
-    def sound_mode_list(self) -> None:
+    def sound_mode_list(self) -> List[str]:
         """Return a list of available sound modes as string."""
         return list(self._sound_mode_map.keys())
 
@@ -280,6 +287,9 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         Valid values depend on the device and should be taken from
         "sound_mode_list".
         """
+        if sound_mode not in self.sound_mode_list:
+            raise AvrCommandError(f"{sound_mode} is not a valid sound mode")
+
         if sound_mode == ALL_ZONE_STEREO:
             await self._async_set_all_zone_stereo(True)
             return
@@ -291,8 +301,14 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         # Therefore source mapping is needed to get sound_mode
         # Create command URL and send command via HTTP GET
         command_url = self._device.urls.command_sel_sound_mode + sound_mode
+        telnet_command = (
+            self._device.telnet_commands.command_sel_sound_mode + sound_mode
+        )
         # sent command
-        await self._device.api.async_get_command(command_url)
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(telnet_command)
+        else:
+            await self._device.api.async_get_command(command_url)
 
 
 def sound_mode_factory(instance: DenonAVRFoundation) -> DenonAVRSoundMode:

denonavr/ssdp.py

@@ -35,14 +35,14 @@ SSDP_ST_LIST = (SSDP_ST_1, SSDP_ST_2, SSDP_ST_3)
 SSDP_LOCATION_PATTERN = re.compile(r"(?<=LOCATION:\s).+?(?=\r)")
 
 SCPD_XMLNS = "{urn:schemas-upnp-org:device-1-0}"
-SCPD_DEVICE = "{xmlns}device".format(xmlns=SCPD_XMLNS)
-SCPD_DEVICELIST = "{xmlns}deviceList".format(xmlns=SCPD_XMLNS)
-SCPD_DEVICETYPE = "{xmlns}deviceType".format(xmlns=SCPD_XMLNS)
-SCPD_MANUFACTURER = "{xmlns}manufacturer".format(xmlns=SCPD_XMLNS)
-SCPD_MODELNAME = "{xmlns}modelName".format(xmlns=SCPD_XMLNS)
-SCPD_SERIALNUMBER = "{xmlns}serialNumber".format(xmlns=SCPD_XMLNS)
-SCPD_FRIENDLYNAME = "{xmlns}friendlyName".format(xmlns=SCPD_XMLNS)
-SCPD_PRESENTATIONURL = "{xmlns}presentationURL".format(xmlns=SCPD_XMLNS)
+SCPD_DEVICE = f"{SCPD_XMLNS}device"
+SCPD_DEVICELIST = f"{SCPD_XMLNS}deviceList"
+SCPD_DEVICETYPE = f"{SCPD_XMLNS}deviceType"
+SCPD_MANUFACTURER = f"{SCPD_XMLNS}manufacturer"
+SCPD_MODELNAME = f"{SCPD_XMLNS}modelName"
+SCPD_SERIALNUMBER = f"{SCPD_XMLNS}serialNumber"
+SCPD_FRIENDLYNAME = f"{SCPD_XMLNS}friendlyName"
+SCPD_PRESENTATIONURL = f"{SCPD_XMLNS}presentationURL"
 
 SUPPORTED_DEVICETYPES = [
     "urn:schemas-upnp-org:device:MediaRenderer:1",
@@ -57,10 +57,10 @@ def ssdp_request(ssdp_st: str, ssdp_mx: float = SSDP_MX) -> bytes:
     return "\r\n".join(
         [
             "M-SEARCH * HTTP/1.1",
-            "ST: {}".format(ssdp_st),
-            "MX: {:d}".format(ssdp_mx),
+            f"ST: {ssdp_st}",
+            f"MX: {ssdp_mx:d}",
             'MAN: "ssdp:discover"',
-            "HOST: {}:{}".format(*SSDP_TARGET),
+            f"HOST: {SSDP_ADDR}:{SSDP_PORT}",
             "",
             "",
         ]
@@ -133,8 +133,8 @@ async def async_send_ssdp_broadcast() -> Set[str]:
 
 async def async_send_ssdp_broadcast_ip(ip_addr: str) -> Set[str]:
     """Send SSDP broadcast messages to a single IP."""
-    # Ignore 169.254.0.0/16 adresses
-    if re.search("169.254.*.*", ip_addr):
+    # Ignore 169.254.0.0/16 addresses
+    if ip_addr.startswith("169.254."):
         return set()
 
     # Prepare socket