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

denonavr/foundation.py

@@ -15,7 +15,6 @@ from copy import deepcopy
 from typing import Dict, List, Optional, Union
 
 import attr
-import httpx
 
 from .api import DenonAVRApi, DenonAVRTelnetApi
 from .appcommand import AppCommandCmd, AppCommands
@@ -143,16 +142,19 @@ class DenonAVRDeviceInfo:
     async def async_setup(self) -> None:
         """Ensure that configuration is loaded from receiver asynchronously."""
         async with self._setup_lock:
-            # Own setup
+            _LOGGER.debug("Starting device setup")
             # Reduce read timeout during receiver identification
             # deviceinfo endpoint takes very long to return 404
-            timeout = self.api.timeout
-            self.api.timeout = httpx.Timeout(self.api.timeout.connect)
+            read_timeout = self.api.read_timeout
+            self.api.read_timeout = self.api.timeout
             try:
+                _LOGGER.debug("Identifying receiver")
                 await self.async_identify_receiver()
+                _LOGGER.debug("Getting device info")
                 await self.async_get_device_info()
             finally:
-                self.api.timeout = timeout
+                self.api.read_timeout = read_timeout
+            _LOGGER.debug("Identifying update method")
             await self.async_identify_update_method()
 
             # Add tags for a potential AppCommand.xml update
@@ -166,17 +168,20 @@ class DenonAVRDeviceInfo:
             self.telnet_api.register_callback(power_event, self._async_power_callback)
 
             self._is_setup = True
+            _LOGGER.debug("Finished device setup")
 
     async def async_update(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
         """Update status asynchronously."""
+        _LOGGER.debug("Starting device update")
         # Ensure instance is setup before updating
         if not self._is_setup:
             await self.async_setup()
 
         # Update power status
         await self.async_update_power(global_update=global_update, cache_id=cache_id)
+        _LOGGER.debug("Finished device update")
 
     async def async_identify_receiver(self) -> None:
         """Identify receiver asynchronously."""
@@ -196,9 +201,9 @@ class DenonAVRDeviceInfo:
                 )
             except (AvrTimoutError, AvrNetworkError) as err:
                 _LOGGER.debug(
-                    "Connection error on port %s when identifying receiver",
+                    "Connection error on port %s when identifying receiver: %s",
                     r_type.port,
-                    exc_info=err,
+                    err,
                 )
 
                 # Raise error only when occurred at both types
@@ -210,22 +215,32 @@ class DenonAVRDeviceInfo:
                 _LOGGER.debug(
                     (
                         "Request error on port %s when identifying receiver, "
-                        "device is not a %s receivers"
+                        "device is not a %s receiver: %s"
                     ),
                     r_type.port,
                     r_type.type,
-                    exc_info=err,
+                    err,
                 )
             else:
                 is_avr_x = self._is_avr_x(xml)
                 if is_avr_x:
                     self.receiver = r_type
+                    _LOGGER.info(
+                        "Identified %s receiver using port %s",
+                        r_type.type,
+                        r_type.port,
+                    )
                     # Receiver identified, return
                     return
 
         # If check of Deviceinfo.xml was not successful, receiver is type AVR
         self.receiver = AVR
         self.api.port = AVR.port
+        _LOGGER.info(
+            "Identified %s receiver using port %s",
+            AVR.type,
+            AVR.port,
+        )
 
     @staticmethod
     def _is_avr_x(deviceinfo: ET.Element) -> bool:
@@ -275,13 +290,11 @@ class DenonAVRDeviceInfo:
                 )
             except (AvrTimoutError, AvrNetworkError) as err:
                 _LOGGER.debug(
-                    "Connection error when identifying update method", exc_info=err
+                    "Connection error when identifying update method: %s", err
                 )
                 raise
             except AvrRequestError as err:
-                _LOGGER.debug(
-                    "Request error when identifying update method", exc_info=err
-                )
+                _LOGGER.debug("Request error when identifying update method: %s", err)
                 self.use_avr_2016_update = False
                 _LOGGER.info("AVR-X device, AppCommand.xml interface not supported")
             else:
@@ -294,11 +307,11 @@ class DenonAVRDeviceInfo:
                 xml = await self.api.async_get_xml(self.urls.mainzone)
             except (AvrTimoutError, AvrNetworkError) as err:
                 _LOGGER.debug(
-                    "Connection error when identifying update method", exc_info=err
+                    "Connection error when identifying update method: %s", err
                 )
                 raise
             except AvrRequestError as err:
-                _LOGGER.debug("Request error getting friendly name", exc_info=err)
+                _LOGGER.debug("Request error getting friendly name: %s", err)
                 _LOGGER.info(
                     "Receiver name could not be determined. Using standard"
                     " name: Denon AVR"
@@ -309,7 +322,7 @@ class DenonAVRDeviceInfo:
                 self._set_friendly_name(xml)
 
     async def async_verify_avr_2016_update_method(
-        self, cache_id: Hashable = None
+        self, *, cache_id: Hashable = None
     ) -> None:
         """Verify if avr 2016 update method is working."""
         # Nothing to do if Appcommand.xml interface is not supported
@@ -320,7 +333,7 @@ class DenonAVRDeviceInfo:
             # Result is cached that it can be reused during update
             await self.api.async_get_global_appcommand(cache_id=cache_id)
         except (AvrTimoutError, AvrNetworkError) as err:
-            _LOGGER.debug("Connection error when verifying update method", exc_info=err)
+            _LOGGER.debug("Connection error when verifying update method: %s", err)
             raise
         except AvrForbiddenError:
             # Recovery in case receiver changes port from 80 to 8080 which
@@ -338,7 +351,7 @@ class DenonAVRDeviceInfo:
             else:
                 raise
         except AvrIncompleteResponseError as err:
-            _LOGGER.debug("Request error when verifying update method", exc_info=err)
+            _LOGGER.debug("Request error when verifying update method: %s", err)
             # Only AVR_X devices support both interfaces
             if self.receiver == AVR_X:
                 _LOGGER.warning(
@@ -378,10 +391,10 @@ class DenonAVRDeviceInfo:
         try:
             res = await self.api.async_get(command, port=port)
         except AvrTimoutError as err:
-            _LOGGER.debug("Timeout when getting device info", exc_info=err)
+            _LOGGER.debug("Timeout when getting device info: %s", err)
             raise
         except AvrNetworkError as err:
-            _LOGGER.debug("Network error getting device info", exc_info=err)
+            _LOGGER.debug("Network error getting device info: %s", err)
             raise
         except AvrRequestError as err:
             _LOGGER.error(
@@ -444,7 +457,7 @@ class DenonAVRDeviceInfo:
                     self.urls.appcommand, tuple(power_appcommand), cache_id=cache_id
                 )
         except AvrRequestError as err:
-            _LOGGER.debug("Error when getting power status", exc_info=err)
+            _LOGGER.debug("Error when getting power status: %s", err)
             raise
 
         # Extract relevant information
@@ -482,7 +495,7 @@ class DenonAVRDeviceInfo:
                     xml = await self.api.async_get_xml(url, cache_id=cache_id)
                 except AvrRequestError as err:
                     _LOGGER.debug(
-                        "Error when getting power status from url %s", url, exc_info=err
+                        "Error when getting power status from url %s: %s", url, err
                     )
                     continue
 
@@ -535,6 +548,87 @@ class DenonAVRDeviceInfo:
         else:
             await self.api.async_get_command(self.urls.command_power_standby)
 
+    async def async_cursor_up(self) -> None:
+        """Cursor Up on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_cusor_up
+            )
+        else:
+            await self.api.async_get_command(self.urls.command_cusor_up)
+
+    async def async_cursor_down(self) -> None:
+        """Cursor Down on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_cusor_down
+            )
+        else:
+            await self.api.async_get_command(self.urls.command_cusor_down)
+
+    async def async_cursor_left(self) -> None:
+        """Cursor Left on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_cusor_left
+            )
+        else:
+            await self.api.async_get_command(self.urls.command_cusor_left)
+
+    async def async_cursor_right(self) -> None:
+        """Cursor Right on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_cusor_right
+            )
+        else:
+            await self.api.async_get_command(self.urls.command_cusor_right)
+
+    async def async_cursor_enter(self) -> None:
+        """Cursor Enter on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_cusor_enter
+            )
+        else:
+            await self.api.async_get_command(self.urls.command_cusor_enter)
+
+    async def async_back(self) -> None:
+        """Back command on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(self.telnet_commands.command_back)
+        else:
+            await self.api.async_get_command(self.urls.command_back)
+
+    async def async_info(self) -> None:
+        """Info OSD on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(self.telnet_commands.command_info)
+        else:
+            await self.api.async_get_command(self.urls.command_info)
+
+    async def async_options(self) -> None:
+        """Options menu on receiver via HTTP get command."""
+        await self.api.async_get_command(self.urls.command_options)
+
+    async def async_settings_menu(self) -> None:
+        """Options menu on receiver via HTTP get command."""
+        res = await self.api.async_get_command(self.urls.command_setup_query)
+        if self.telnet_available:
+            if res is not None and res == "MNMEN ON":
+                await self.telnet_api.async_send_commands(
+                    self.telnet_commands.command_setup_close
+                )
+            else:
+                await self.telnet_api.async_send_commands(
+                    self.telnet_commands.command_setup_open
+                )
+        else:
+            if res is not None and res == "MNMEN ON":
+                await self.api.async_get_command(self.urls.command_setup_close)
+            else:
+                await self.api.async_get_command(self.urls.command_setup_open)
+
 
 @attr.s(auto_attribs=True, on_setattr=DENON_ATTR_SETATTR)
 class DenonAVRFoundation:
@@ -558,7 +652,6 @@ class DenonAVRFoundation:
         appcommand0300: bool = False,
         global_update: bool = False,
         cache_id: Optional[Hashable] = None,
-        ignore_missing_response: bool = False,
     ):
         """Update attributes from AppCommand.xml."""
         # Copy that we do not accidently change the wrong dict
@@ -581,7 +674,7 @@ class DenonAVRFoundation:
                     url, tags, cache_id=cache_id
                 )
         except AvrRequestError as err:
-            _LOGGER.debug("Error when getting status update", exc_info=err)
+            _LOGGER.debug("Error when getting status update: %s", err)
             raise
 
         # Extract relevant information
@@ -616,10 +709,10 @@ class DenonAVRFoundation:
 
                 except (AttributeError, IndexError) as err:
                     _LOGGER.debug(
-                        "Failed updating attribute %s for zone %s",
+                        "Failed updating attribute %s for zone %s: %s",
                         pattern.update_attribute,
                         self._device.zone,
-                        exc_info=err,
+                        err,
                     )
 
             if start == success:
@@ -627,24 +720,17 @@ class DenonAVRFoundation:
                 update_attrs.pop(app_command, None)
 
         # Check if each attribute was updated
-        if update_attrs and not ignore_missing_response:
+        if update_attrs:
             raise AvrProcessingError(
                 f"Some attributes of zone {self._device.zone} not found on update:"
                 f" {update_attrs}"
             )
-        if update_attrs and ignore_missing_response:
-            _LOGGER.debug(
-                "Some attributes of zone %s not found on update: %s",
-                self._device.zone,
-                update_attrs,
-            )
 
     async def async_update_attrs_status_xml(
         self,
         update_attrs: Dict[str, str],
         urls: List[str],
         cache_id: Optional[Hashable] = None,
-        ignore_missing_response: bool = False,
     ):
         """
         Update attributes from status xml.
@@ -664,7 +750,7 @@ class DenonAVRFoundation:
                 xml = await self._device.api.async_get_xml(url, cache_id=cache_id)
             except AvrRequestError as err:
                 _LOGGER.debug(
-                    "Error when getting status update from url %s", url, exc_info=err
+                    "Error when getting status update from url %s: %s", url, err
                 )
                 continue
             attrs = deepcopy(update_attrs)
@@ -683,10 +769,10 @@ class DenonAVRFoundation:
 
                 except (AttributeError, IndexError) as err:
                     _LOGGER.debug(
-                        "Failed updating attribute %s for zone %s",
+                        "Failed updating attribute %s for zone %s: %s",
                         name,
                         self._device.zone,
-                        exc_info=err,
+                        err,
                     )
 
             # All done, no need for continuing
@@ -694,7 +780,7 @@ class DenonAVRFoundation:
                 break
 
         # Check if each attribute was updated
-        if update_attrs and not ignore_missing_response:
+        if update_attrs:
             raise AvrProcessingError(
                 f"Some attributes of zone {self._device.zone} not found on update:"
                 f" {update_attrs}"
@@ -746,9 +832,9 @@ def set_api_timeout(
 ) -> float:
     """Change API timeout on timeout changes too."""
     # First change _device.api.host then return value
-    timeout = httpx.Timeout(value, read=max(value, 15.0))
     # pylint: disable=protected-access
-    instance._device.api.timeout = timeout
+    instance._device.api.timeout = value
+    instance._device.api.read_timeout = max(value, 15.0)
     instance._device.telnet_api.timeout = value
     return value
 

denonavr/input.py

@@ -168,6 +168,13 @@ class DenonAVRInput(DenonAVRFoundation):
         converter=attr.converters.optional(str), default=None
     )
 
+    _renamed_sources_warnings: Set[Tuple[str, str]] = attr.ib(
+        validator=attr.validators.deep_iterable(
+            attr.validators.instance_of(tuple), attr.validators.instance_of(set)
+        ),
+        default=attr.Factory(set),
+    )
+
     # Update tags for attributes
     # AppCommand.xml interface
     appcommand_attrs = {AppCommands.GetAllZoneSource: None}
@@ -273,7 +280,7 @@ class DenonAVRInput(DenonAVRFoundation):
     def _update_netaudio(self) -> None:
         """Update netaudio information."""
         if self._device.telnet_available:
-            self._device.telnet_api.send_commands("NSE")
+            self._device.telnet_api.send_commands("NSE", skip_confirmation=True)
             self._schedule_netaudio_update()
         else:
             self._stop_media_update()
@@ -316,7 +323,9 @@ class DenonAVRInput(DenonAVRFoundation):
     def _update_tuner(self) -> None:
         """Update tuner information."""
         if self._device.telnet_available:
-            self._device.telnet_api.send_commands("TFAN?", "TFANNAME?")
+            self._device.telnet_api.send_commands(
+                "TFAN?", "TFANNAME?", skip_confirmation=True
+            )
             self._schedule_tuner_update()
         else:
             self._stop_media_update()
@@ -360,7 +369,7 @@ class DenonAVRInput(DenonAVRFoundation):
     def _update_hdtuner(self) -> None:
         """Update HD tuner information."""
         if self._device.telnet_available:
-            self._device.telnet_api.send_commands("HD?")
+            self._device.telnet_api.send_commands("HD?", skip_confirmation=True)
             self._schedule_hdtuner_update()
         else:
             self._stop_media_update()
@@ -405,18 +414,23 @@ class DenonAVRInput(DenonAVRFoundation):
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
         """Update input functions asynchronously."""
+        _LOGGER.debug("Starting input update")
         # Ensure instance is setup before updating
         if not self._is_setup:
             self.setup()
 
         # Update input functions
+        _LOGGER.debug("Updating input functions")
         await self.async_update_inputfuncs(
             global_update=global_update, cache_id=cache_id
         )
         # Update state
+        _LOGGER.debug("Updating input state")
         await self.async_update_state(global_update=global_update, cache_id=cache_id)
         # Update media state
+        _LOGGER.debug("Updating media state")
         await self.async_update_media_state(cache_id=cache_id)
+        _LOGGER.debug("Finished input update")
 
     async def async_get_sources_deviceinfo(self) -> Dict[str, str]:
         """Get sources from Deviceinfo.xml."""
@@ -426,7 +440,7 @@ class DenonAVRInput(DenonAVRFoundation):
                 self._device.urls.deviceinfo, cache_id=id(self._device)
             )
         except AvrRequestError as err:
-            _LOGGER.debug("Error when getting sources", exc_info=err)
+            _LOGGER.debug("Error when getting sources: %s", err)
             raise
 
         receiver_sources = {}
@@ -484,7 +498,7 @@ class DenonAVRInput(DenonAVRFoundation):
                     self._device.urls.appcommand, tags, cache_id=cache_id
                 )
         except AvrRequestError as err:
-            _LOGGER.debug("Error when getting changed sources", exc_info=err)
+            _LOGGER.debug("Error when getting changed sources: %s", err)
             raise
 
         for child in xml.findall(
@@ -509,6 +523,8 @@ class DenonAVRInput(DenonAVRFoundation):
             except AttributeError:
                 continue
 
+        self._replace_duplicate_sources(renamed_sources)
+
         return (renamed_sources, deleted_sources)
 
     async def async_get_changed_sources_status_xml(
@@ -547,7 +563,7 @@ class DenonAVRInput(DenonAVRFoundation):
                     f" {self._device.receiver.type}"
                 )
         except AvrRequestError as err:
-            _LOGGER.debug("Error when getting changed sources", exc_info=err)
+            _LOGGER.debug("Error when getting changed sources: %s", err)
             raise
 
         # Get the relevant tags from XML structure
@@ -597,6 +613,8 @@ class DenonAVRInput(DenonAVRFoundation):
             except IndexError:
                 _LOGGER.error("List of deleted sources incomplete, continuing anyway")
 
+        self._replace_duplicate_sources(renamed_sources)
+
         return (renamed_sources, deleted_sources)
 
     async def async_update_inputfuncs(
@@ -852,10 +870,13 @@ class DenonAVRInput(DenonAVRFoundation):
     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()
+            client = self._device.api.httpx_async_client.client_getter()
             try:
                 res = await client.get(
-                    self._image_url, timeout=self._device.api.timeout
+                    self._image_url,
+                    timeout=httpx.Timeout(
+                        self._device.api.timeout, read=self._device.api.read_timeout
+                    ),
                 )
                 res.raise_for_status()
             except httpx.TimeoutException:
@@ -871,7 +892,7 @@ class DenonAVRInput(DenonAVRFoundation):
                 self._image_available = True
             finally:
                 # Close the default AsyncClient but keep custom clients open
-                if self._device.api.is_default_async_client():
+                if self._device.api.httpx_async_client.is_default_async_client():
                     await client.aclose()
         # Already tested that image URL is not accessible
         elif not self._image_available:
@@ -887,6 +908,33 @@ class DenonAVRInput(DenonAVRFoundation):
         self._station = None
         self._image_url = None
 
+    def _replace_duplicate_sources(self, sources: Dict[str, str]) -> None:
+        """Replace duplicate renamed sources (values) with their original names."""
+        seen_values = set()
+        duplicate_values = set()
+
+        for value in sources.values():
+            if value in seen_values:
+                duplicate_values.add(value)
+            seen_values.add(value)
+
+        for duplicate in duplicate_values:
+            for key, value in sources.items():
+                if value == duplicate:
+                    sources[key] = key
+
+                    if (key, value) not in self._renamed_sources_warnings:
+                        _LOGGER.warning(
+                            (
+                                "Input source '%s' is renamed to non-unique name '%s'. "
+                                "Using original name. Please choose unique names in "
+                                "your receiver's web-interface"
+                            ),
+                            key,
+                            value,
+                        )
+                        self._renamed_sources_warnings.add((key, value))
+
     ##############
     # Properties #
     ##############

denonavr/soundmode.py

@@ -16,14 +16,8 @@ from typing import Dict, List, Optional
 import attr
 
 from .appcommand import AppCommands
-from .const import (
-    ALL_ZONE_STEREO,
-    AVR_X,
-    AVR_X_2016,
-    DENON_ATTR_SETATTR,
-    SOUND_MODE_MAPPING,
-)
-from .exceptions import AvrCommandError, AvrProcessingError
+from .const import ALL_ZONE_STEREO, DENON_ATTR_SETATTR, SOUND_MODE_MAPPING
+from .exceptions import AvrCommandError, AvrIncompleteResponseError, AvrProcessingError
 from .foundation import DenonAVRFoundation
 
 _LOGGER = logging.getLogger(__name__)
@@ -94,6 +88,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         init=False,
     )
     _setup_lock: asyncio.Lock = attr.ib(default=attr.Factory(asyncio.Lock))
+    _appcommand_active: bool = attr.ib(converter=bool, default=True, init=False)
 
     # Update tags for attributes
     # AppCommand.xml interface
@@ -105,22 +100,22 @@ class DenonAVRSoundMode(DenonAVRFoundation):
     async def async_setup(self) -> None:
         """Ensure that the instance is initialized."""
         async with self._setup_lock:
-            # Add tags for a potential AppCommand.xml update
-            for tag in self.appcommand_attrs:
-                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 during the first update
-            if self._device.receiver in [AVR_X, AVR_X_2016]:
-                self._support_sound_mode = True
-            else:
-                await self.async_update_sound_mode()
+            _LOGGER.debug("Starting sound mode setup")
+
+            # The first update determines if sound mode is supported
+            await self.async_update_sound_mode()
+
+            if self._support_sound_mode and self._appcommand_active:
+                # Add tags for a potential AppCommand.xml update
+                for tag in self.appcommand_attrs:
+                    self._device.api.add_appcommand_update_tag(tag)
 
             self._device.telnet_api.register_callback(
                 "MS", self._async_soundmode_callback
             )
 
             self._is_setup = True
+            _LOGGER.debug("Finished sound mode setup")
 
     async def _async_soundmode_callback(
         self, zone: str, event: str, parameter: str
@@ -135,6 +130,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
         """Update sound mode asynchronously."""
+        _LOGGER.debug("Starting sound mode update")
         # Ensure instance is setup before updating
         if not self._is_setup:
             await self.async_setup()
@@ -143,6 +139,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         await self.async_update_sound_mode(
             global_update=global_update, cache_id=cache_id
         )
+        _LOGGER.debug("Finished sound mode update")
 
     async def async_update_sound_mode(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
@@ -153,29 +150,47 @@ class DenonAVRSoundMode(DenonAVRFoundation):
                 "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
-            )
-        else:
-            urls = [self._device.urls.status, self._device.urls.mainzone]
-            if self._is_setup and not self._support_sound_mode:
+        if self._is_setup and not self._support_sound_mode:
+            return
+
+        if self._device.use_avr_2016_update and self._appcommand_active:
+            try:
+                await self.async_update_attrs_appcommand(
+                    self.appcommand_attrs,
+                    global_update=global_update,
+                    cache_id=cache_id,
+                )
+            except (AvrProcessingError, AvrIncompleteResponseError):
+                self._appcommand_active = False
+                _LOGGER.debug(
+                    "Appcommand.xml does not support Sound mode. "
+                    "Testing status.xml interface next"
+                )
+            else:
+                if not self._is_setup:
+                    self._support_sound_mode = True
+                    _LOGGER.info("Sound mode supported")
                 return
-            # There are two different options of sound mode tags
+
+        urls = [self._device.urls.status, self._device.urls.mainzone]
+        # There are two different options of sound mode tags
+        try:
+            await self.async_update_attrs_status_xml(
+                self.status_xml_attrs_01, urls, cache_id=cache_id
+            )
+        except AvrProcessingError:
             try:
                 await self.async_update_attrs_status_xml(
-                    self.status_xml_attrs_01, urls, cache_id=cache_id
+                    self.status_xml_attrs_02, urls, cache_id=cache_id
                 )
             except AvrProcessingError:
-                try:
-                    await self.async_update_attrs_status_xml(
-                        self.status_xml_attrs_02, urls, cache_id=cache_id
-                    )
-                except AvrProcessingError:
-                    _LOGGER.info("Sound mode not supported")
-                    self._support_sound_mode = False
-                    return
+                self._support_sound_mode = False
+                _LOGGER.info("Sound mode not supported")
+                return
+
+        if not self._is_setup:
             self._support_sound_mode = True
+            _LOGGER.info("Sound mode supported")
 
     def match_sound_mode(self) -> Optional[str]:
         """Match the raw_sound_mode to its corresponding sound_mode."""
@@ -248,7 +263,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
     ##############
     @property
     def support_sound_mode(self) -> Optional[bool]:
-        """Return True if sound mode supported."""
+        """Return True if sound mode is supported."""
         return self._support_sound_mode
 
     @property