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

denonavr/foundation.py

@@ -10,8 +10,9 @@ This module implements the foundation classes for Denon AVR receivers.
 import asyncio
 import logging
 import xml.etree.ElementTree as ET
+from collections.abc import Hashable
 from copy import deepcopy
-from typing import Dict, Hashable, List, Optional
+from typing import Dict, List, Optional, Union
 
 import attr
 import httpx
@@ -119,7 +120,7 @@ class DenonAVRDeviceInfo:
             self.telnet_commands = ZONE3_TELNET_COMMANDS
             self.urls = ZONE3_URLS
         else:
-            raise ValueError("Invalid zone {}".format(self.zone))
+            raise ValueError(f"Invalid zone {self.zone}")
 
     async def _async_power_callback(
         self, zone: str, event: str, parameter: str
@@ -179,7 +180,7 @@ class DenonAVRDeviceInfo:
 
     async def async_identify_receiver(self) -> None:
         """Identify receiver asynchronously."""
-        # Test Deviceinfo.xml if receiver is a AVR-X with port 80 for pre 2016
+        # Test Deviceinfo.xml if receiver is an AVR-X with port 80 for pre 2016
         # devices and port 8080 devices 2016 and later
         # 2016 models has also some of the XML but not all, try first 2016
         r_types = [AVR_X, AVR_X_2016]
@@ -200,15 +201,17 @@ class DenonAVRDeviceInfo:
                     exc_info=err,
                 )
 
-                # Raise error only when occured at both types
+                # Raise error only when occurred at both types
                 timeout_errors += 1
                 if timeout_errors == len(r_types):
                     raise
 
             except AvrRequestError as err:
                 _LOGGER.debug(
-                    "Request error on port %s when identifying receiver, "
-                    "device is not a %s receivers",
+                    (
+                        "Request error on port %s when identifying receiver, "
+                        "device is not a %s receivers"
+                    ),
                     r_type.port,
                     r_type.type,
                     exc_info=err,
@@ -220,13 +223,13 @@ class DenonAVRDeviceInfo:
                     # Receiver identified, return
                     return
 
-        # If check of Deviceinfo.xml was not successfull, receiver is type AVR
+        # If check of Deviceinfo.xml was not successful, receiver is type AVR
         self.receiver = AVR
         self.api.port = AVR.port
 
     @staticmethod
     def _is_avr_x(deviceinfo: ET.Element) -> bool:
-        """Evaluate Deviceinfo.xml if the device is a AVR-X device."""
+        """Evaluate Deviceinfo.xml if the device is an AVR-X device."""
         # First test by CommApiVers
         try:
             if bool(
@@ -369,9 +372,7 @@ class DenonAVRDeviceInfo:
         """Get device information."""
         port = DESCRIPTION_TYPES[self.receiver.type].port
         command = DESCRIPTION_TYPES[self.receiver.type].url
-        url = "http://{host}:{port}{command}".format(
-            host=self.api.host, port=port, command=command
-        )
+        url = f"http://{self.api.host}:{port}{command}"
 
         device_info = None
         try:
@@ -384,8 +385,10 @@ class DenonAVRDeviceInfo:
             raise
         except AvrRequestError as err:
             _LOGGER.error(
-                "During DenonAVR device identification, when trying to request"
-                " %s the following error occurred: %s",
+                (
+                    "During DenonAVR device identification, when trying to request"
+                    " %s the following error occurred: %s"
+                ),
                 url,
                 err,
             )
@@ -397,9 +400,11 @@ class DenonAVRDeviceInfo:
             self.model_name = "Unknown"
             self.serial_number = None
             _LOGGER.warning(
-                "Unable to get device information of host %s, Device might be "
-                "in a corrupted state. Continuing without device information. "
-                "Disconnect and reconnect power to the device and try again.",
+                (
+                    "Unable to get device information of host %s, Device might be "
+                    "in a corrupted state. Continuing without device information. "
+                    "Disconnect and reconnect power to the device and try again."
+                ),
                 self.api.host,
             )
             return
@@ -447,14 +452,12 @@ class DenonAVRDeviceInfo:
 
         # Search for power tag
         power_tag = xml.find(
-            "./cmd[@{attribute}='{cmd}']/{zone}".format(
-                attribute=APPCOMMAND_CMD_TEXT, cmd=power_appcommand.cmd_text, zone=zone
-            )
+            f"./cmd[@{APPCOMMAND_CMD_TEXT}='{power_appcommand.cmd_text}']/{zone}"
         )
 
         if power_tag is None:
             raise AvrProcessingError(
-                "Power attribute of zone {} not found on update".format(self.zone)
+                f"Power attribute of zone {self.zone} not found on update"
             )
 
         self._power = power_tag.text
@@ -468,7 +471,7 @@ class DenonAVRDeviceInfo:
         if self.zone == MAIN_ZONE:
             urls.append(self.urls.mainzone)
         else:
-            urls.append("{}?ZoneName={}".format(self.urls.mainzone, self.zone))
+            urls.append(f"{self.urls.mainzone}?ZoneName={self.zone}")
         # Tags in XML which might contain information about zones power status
         # ordered by their priority
         tags = ["./ZonePower/value", "./Power/value"]
@@ -490,7 +493,7 @@ class DenonAVRDeviceInfo:
                     return
 
         raise AvrProcessingError(
-            "Power attribute of zone {} not found on update".format(self.zone)
+            f"Power attribute of zone {self.zone} not found on update"
         )
 
     ##############
@@ -505,22 +508,31 @@ class DenonAVRDeviceInfo:
         """
         return self._power
 
+    @property
+    def telnet_available(self) -> bool:
+        """Return true if telnet is connected and healthy."""
+        return self.telnet_api.connected and self.telnet_api.healthy
+
     ##########
     # Setter #
     ##########
 
     async def async_power_on(self) -> None:
         """Turn on receiver via HTTP get command."""
-        success = self.telnet_api.send_commands(self.telnet_commands.command_power_on)
-        if not success:
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_power_on
+            )
+        else:
             await self.api.async_get_command(self.urls.command_power_on)
 
     async def async_power_off(self) -> None:
         """Turn off receiver via HTTP get command."""
-        success = self.telnet_api.send_commands(
-            self.telnet_commands.command_power_standby
-        )
-        if not success:
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_power_standby
+            )
+        else:
             await self.api.async_get_command(self.urls.command_power_standby)
 
 
@@ -617,9 +629,8 @@ class DenonAVRFoundation:
         # Check if each attribute was updated
         if update_attrs and not ignore_missing_response:
             raise AvrProcessingError(
-                "Some attributes of zone {} not found on update: {}".format(
-                    self._device.zone, update_attrs
-                )
+                f"Some attributes of zone {self._device.zone} not found on update:"
+                f" {update_attrs}"
             )
         if update_attrs and ignore_missing_response:
             _LOGGER.debug(
@@ -685,9 +696,8 @@ class DenonAVRFoundation:
         # Check if each attribute was updated
         if update_attrs and not ignore_missing_response:
             raise AvrProcessingError(
-                "Some attributes of zone {} not found on update: {}".format(
-                    self._device.zone, update_attrs
-                )
+                f"Some attributes of zone {self._device.zone} not found on update:"
+                f" {update_attrs}"
             )
 
     @staticmethod
@@ -701,17 +711,15 @@ class DenonAVRFoundation:
             string = "./cmd"
             # Text of cmd tag in query was added as attribute to response
             if app_command_cmd.cmd_text:
-                string = string + "[@{}='{}']".format(
-                    APPCOMMAND_CMD_TEXT, app_command_cmd.cmd_text
+                string = (
+                    string + f"[@{APPCOMMAND_CMD_TEXT}='{app_command_cmd.cmd_text}']"
                 )
             # Text of name tag in query was added as attribute to response
             if app_command_cmd.name:
-                string = string + "[@{}='{}']".format(
-                    APPCOMMAND_NAME, app_command_cmd.name
-                )
+                string = string + f"[@{APPCOMMAND_NAME}='{app_command_cmd.name}']"
             # Some results include a zone tag
             if resp.add_zone:
-                string = string + "/{}".format(zone)
+                string = string + f"/{zone}"
             # Suffix like /status, /volume
             string = string + resp.suffix
 
@@ -745,8 +753,10 @@ def set_api_timeout(
     return value
 
 
-def convert_string_int_bool(value: str) -> bool:
+def convert_string_int_bool(value: Union[str, bool]) -> bool:
     """Convert an integer from string format to bool."""
     if value is None:
         return None
+    if isinstance(value, bool):
+        return value
     return bool(int(value))

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, Set, 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,11 +57,11 @@ 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)).strip("\x00").strip("\x01").strip()
+    return fix_text(str(value)).strip()
 
 
 def set_input_func(
@@ -143,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
@@ -271,7 +272,8 @@ class DenonAVRInput(DenonAVRFoundation):
 
     def _update_netaudio(self) -> None:
         """Update netaudio information."""
-        if self._device.telnet_api.send_commands("NSE"):
+        if self._device.telnet_available:
+            self._device.telnet_api.send_commands("NSE")
             self._schedule_netaudio_update()
         else:
             self._stop_media_update()
@@ -301,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."""
@@ -313,7 +315,8 @@ class DenonAVRInput(DenonAVRFoundation):
 
     def _update_tuner(self) -> None:
         """Update tuner information."""
-        if self._device.telnet_api.send_commands("TFAN?", "TFANNAME?"):
+        if self._device.telnet_available:
+            self._device.telnet_api.send_commands("TFAN?", "TFANNAME?")
             self._schedule_tuner_update()
         else:
             self._stop_media_update()
@@ -330,7 +333,7 @@ class DenonAVRInput(DenonAVRFoundation):
         if parameter.startswith("ANNAME"):
             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:
@@ -344,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."""
@@ -356,7 +359,8 @@ class DenonAVRInput(DenonAVRFoundation):
 
     def _update_hdtuner(self) -> None:
         """Update HD tuner information."""
-        if self._device.telnet_api.send_commands("HD?"):
+        if self._device.telnet_available:
+            self._device.telnet_api.send_commands("HD?")
             self._schedule_hdtuner_update()
         else:
             self._stop_media_update()
@@ -386,7 +390,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()
 
     async def _async_input_func_update_callback(
         self, zone: str, event: str, parameter: str
@@ -447,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
 
@@ -484,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(
@@ -496,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()] = (
@@ -541,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)
@@ -668,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])
@@ -846,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:
@@ -995,7 +996,7 @@ class DenonAVRInput(DenonAVRFoundation):
                 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:
@@ -1004,8 +1005,9 @@ class DenonAVRInput(DenonAVRFoundation):
         else:
             command_url = self._device.urls.command_sel_src + linp
             telnet_command = self._device.telnet_commands.command_sel_src + linp
-        success = self._device.telnet_api.send_commands(telnet_command)
-        if not success:
+        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:
@@ -1027,10 +1029,11 @@ class DenonAVRInput(DenonAVRFoundation):
             if self._state == STATE_PLAYING:
                 _LOGGER.info("Already playing, play command not sent")
                 return
-            success = self._device.telnet_api.send_commands(
-                self._device.telnet_commands.command_play
-            )
-            if not success:
+            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
 
@@ -1038,10 +1041,11 @@ class DenonAVRInput(DenonAVRFoundation):
         """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:
-            success = self._device.telnet_api.send_commands(
-                self._device.telnet_commands.command_play
-            )
-            if not success:
+            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
                 )

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__)
@@ -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:
@@ -237,8 +238,9 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         else:
             command_url += "ZST OFF"
             telnet_command += "ZST OFF"
-        success = self._device.telnet_api.send_commands(telnet_command)
-        if not success:
+        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)
 
     ##############
@@ -256,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())
 
@@ -285,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
@@ -300,8 +305,9 @@ class DenonAVRSoundMode(DenonAVRFoundation):
             self._device.telnet_commands.command_sel_sound_mode + sound_mode
         )
         # sent command
-        success = self._device.telnet_api.send_commands(telnet_command)
-        if not success:
+        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)
 
 

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