denonavr 0.11.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

denonavr/foundation.py

@@ -143,16 +143,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)
             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
+            _LOGGER.debug("Identifying update method")
             await self.async_identify_update_method()
 
             # Add tags for a potential AppCommand.xml update
@@ -166,17 +169,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 +202,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 +216,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 +291,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 +308,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"
@@ -320,7 +334,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 +352,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 +392,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 +458,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 +496,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 +549,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 +653,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 +675,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 +710,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 +721,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 +751,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 +770,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 +781,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}"

denonavr/input.py

@@ -272,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", skip_confirmation=True)
             self._schedule_netaudio_update()
         else:
             self._stop_media_update()
@@ -314,7 +315,10 @@ 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?", skip_confirmation=True
+            )
             self._schedule_tuner_update()
         else:
             self._stop_media_update()
@@ -357,7 +361,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?", skip_confirmation=True)
             self._schedule_hdtuner_update()
         else:
             self._stop_media_update()
@@ -402,18 +407,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."""
@@ -423,7 +433,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 = {}
@@ -481,7 +491,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(
@@ -544,7 +554,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

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