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

denonavr/__init__.py

@@ -19,7 +19,7 @@ from .ssdp import async_identify_denonavr_receivers
 logging.getLogger(__name__).addHandler(logging.NullHandler())
 
 __title__ = "denonavr"
-__version__ = "0.11.3"
+__version__ = "0.11.6"
 
 
 async def async_discover():

denonavr/api.py

@@ -14,26 +14,30 @@ import sys
 import time
 import xml.etree.ElementTree as ET
 from collections import defaultdict
+from collections.abc import Hashable
 from io import BytesIO
 from typing import (
     Awaitable,
     Callable,
+    Coroutine,
     DefaultDict,
     Dict,
-    Hashable,
     List,
     Optional,
+    Set,
     Tuple,
     cast,
 )
 
 import attr
 import httpx
-from asyncstdlib import lru_cache
 from defusedxml.ElementTree import fromstring
 
 from .appcommand import AppCommandCmd
 from .const import (
+    ALL_TELNET_EVENTS,
+    ALL_ZONE_TELNET_EVENTS,
+    ALL_ZONES,
     APPCOMMAND0300_URL,
     APPCOMMAND_CMD_TEXT,
     APPCOMMAND_NAME,
@@ -45,15 +49,12 @@ from .const import (
     ZONE2,
     ZONE3,
 )
-from .decorators import (
-    async_handle_receiver_exceptions,
-    cache_clear_on_exception,
-    set_cache_id,
-)
+from .decorators import async_handle_receiver_exceptions, cache_result
 from .exceptions import (
     AvrIncompleteResponseError,
     AvrInvalidResponseError,
     AvrNetworkError,
+    AvrProcessingError,
     AvrTimoutError,
 )
 
@@ -128,9 +129,7 @@ class DenonAVRApi:
         # Use default port of the receiver if no different port is specified
         port = port if port is not None else self.port
 
-        endpoint = "http://{host}:{port}{request}".format(
-            host=self.host, port=port, request=request
-        )
+        endpoint = f"http://{self.host}:{port}{request}"
 
         client = self.async_client_getter()
         try:
@@ -155,9 +154,7 @@ class DenonAVRApi:
         # Use default port of the receiver if no different port is specified
         port = port if port is not None else self.port
 
-        endpoint = "http://{host}:{port}{request}".format(
-            host=self.host, port=port, request=request
-        )
+        endpoint = f"http://{self.host}:{port}{request}"
 
         client = self.async_client_getter()
         try:
@@ -180,9 +177,7 @@ class DenonAVRApi:
         # Return text
         return res.text
 
-    @set_cache_id
-    @cache_clear_on_exception
-    @lru_cache(maxsize=32)
+    @cache_result
     @async_handle_receiver_exceptions
     async def async_get_xml(
         self, request: str, cache_id: Hashable = None
@@ -197,9 +192,7 @@ class DenonAVRApi:
         # Return ElementTree element
         return xml_root
 
-    @set_cache_id
-    @cache_clear_on_exception
-    @lru_cache(maxsize=32)
+    @cache_result
     @async_handle_receiver_exceptions
     async def async_post_appcommand(
         self, request: str, cmds: Tuple[AppCommandCmd], cache_id: Hashable = None
@@ -222,7 +215,7 @@ class DenonAVRApi:
     def add_appcommand_update_tag(self, tag: AppCommandCmd) -> None:
         """Add appcommand tag for full update."""
         if tag.cmd_id != "1":
-            raise ValueError("cmd_id is {} but must be 1".format(tag.cmd_id))
+            raise ValueError(f"cmd_id is {tag.cmd_id} but must be 1")
 
         # Remove response pattern from tag because it is not relevant for query
         tag = attr.evolve(tag, response_pattern=tuple())
@@ -234,7 +227,7 @@ class DenonAVRApi:
     def add_appcommand0300_update_tag(self, tag: AppCommandCmd) -> None:
         """Add appcommand0300 tag for full update."""
         if tag.cmd_id != "3":
-            raise ValueError("cmd_id is {} but must be 3".format(tag.cmd_id))
+            raise ValueError(f"cmd_id is {tag.cmd_id} but must be 3")
 
         # Remove response pattern from tag because it is not relevant for query
         tag = attr.evolve(tag, response_pattern=tuple())
@@ -268,16 +261,20 @@ class DenonAVRApi:
         """
         if len(cmd_list) != len(xml_root):
             raise AvrIncompleteResponseError(
-                "Invalid length of response XML. Query has {} elements, "
-                "response {}".format(len(cmd_list), len(xml_root)),
+                (
+                    "Invalid length of response XML. Query has"
+                    f" {len(cmd_list)} elements, response {len(xml_root)}"
+                ),
                 request,
             )
 
         for i, child in enumerate(xml_root):
             if child.tag not in ["cmd", "error"]:
                 raise AvrInvalidResponseError(
-                    'Returned document contains a tag other than "cmd" and '
-                    '"error": {}'.format(child.tag),
+                    (
+                        'Returned document contains a tag other than "cmd" and'
+                        f' "error": {child.tag}'
+                    ),
                     request,
                 )
             # Find corresponding attributes from request XML if set and add
@@ -354,7 +351,7 @@ class DenonAVRApi:
         return body_bytes
 
     def is_default_async_client(self) -> bool:
-        """Check if default httpx.AsyncCLient getter is used."""
+        """Check if default httpx.AsyncClient getter is used."""
         return self.async_client_getter is get_default_async_client
 
 
@@ -427,11 +424,28 @@ class DenonAVRTelnetApi:
     _telnet_event_map: Dict[str, List] = attr.ib(
         default=attr.Factory(telnet_event_map_factory)
     )
-    _callbacks: Dict[str, Callable] = attr.ib(
+    _callback_tasks: Set[asyncio.Task] = attr.ib(attr.Factory(set))
+    _send_lock: asyncio.Lock = attr.ib(default=attr.Factory(asyncio.Lock))
+    _send_confirmation_timeout: float = attr.ib(converter=float, default=2.0)
+    _send_confirmation_event: asyncio.Event = attr.ib(
+        default=attr.Factory(asyncio.Event)
+    )
+    _send_confirmation_command: str = attr.ib(converter=str, default="")
+    _send_tasks: Set[asyncio.Task] = attr.ib(attr.Factory(set))
+    _callbacks: Dict[str, List[Coroutine]] = attr.ib(
         validator=attr.validators.instance_of(dict),
         default=attr.Factory(dict),
         init=False,
     )
+    _raw_callbacks: List[Coroutine] = attr.ib(
+        validator=attr.validators.instance_of(list),
+        default=attr.Factory(list),
+        init=False,
+    )
+
+    def __attrs_post_init__(self) -> None:
+        """Initialize special attributes."""
+        self._register_raw_callback(self._async_send_confirmation_callback)
 
     async def async_connect(self) -> None:
         """Connect to the receiver asynchronously."""
@@ -457,27 +471,43 @@ class DenonAVRTelnetApi:
                 )
         except asyncio.TimeoutError as err:
             _LOGGER.debug("%s: Timeout exception on telnet connect", self.host)
-            raise AvrTimoutError(
-                "TimeoutException: {}".format(err), "telnet connect"
-            ) from err
+            raise AvrTimoutError(f"TimeoutException: {err}", "telnet connect") from err
         except ConnectionRefusedError as err:
             _LOGGER.debug(
                 "%s: Connection refused on telnet connect", self.host, exc_info=True
             )
             raise AvrNetworkError(
-                "ConnectionRefusedError: {}".format(err), "telnet connect"
+                f"ConnectionRefusedError: {err}", "telnet connect"
             ) from err
         except (OSError, IOError) as err:
             _LOGGER.debug(
                 "%s: Connection failed on telnet reconnect", self.host, exc_info=True
             )
-            raise AvrNetworkError("OSError: {}".format(err), "telnet connect") from err
+            raise AvrNetworkError(f"OSError: {err}", "telnet connect") from err
         _LOGGER.debug("%s: telnet connection complete", self.host)
         self._protocol = cast(DenonAVRTelnetProtocol, transport_protocol[1])
         self._connection_enabled = True
         self._last_message_time = time.monotonic()
         self._schedule_monitor()
-        self._protocol.write("PW?\r")
+        # Trigger update of all attributes
+        await self.async_send_commands(
+            "ZM?",
+            "SI?",
+            "MV?",
+            "MU?",
+            "Z2?",
+            "Z2MU?",
+            "Z3?",
+            "Z3MU?",
+            "PSTONE CTRL ?",
+            "PSBAS ?",
+            "PSTRE ?",
+            "PSDYNEQ ?",
+            "PSMULTEQ: ?",
+            "PSREFLEV ?",
+            "PSDYNVOL ?",
+            "MS?",
+        )
 
     def _schedule_monitor(self) -> None:
         """Start the monitor task."""
@@ -568,8 +598,8 @@ class DenonAVRTelnetApi:
     ) -> None:
         """Register a callback handler for an event type."""
         # Validate the passed in type
-        if event != "ALL" and event not in TELNET_EVENTS:
-            raise ValueError("{} is not a valid callback type.".format(event))
+        if event != ALL_TELNET_EVENTS and event not in TELNET_EVENTS:
+            raise ValueError(f"{event} is not a valid callback type.")
 
         if event not in self._callbacks.keys():
             self._callbacks[event] = []
@@ -583,13 +613,24 @@ class DenonAVRTelnetApi:
             return
         self._callbacks[event].remove(callback)
 
+    def _register_raw_callback(
+        self, callback: Callable[[str], Awaitable[None]]
+    ) -> None:
+        """Register a callback handler for raw telnet messages."""
+        self._raw_callbacks.append(callback)
+
+    def _unregister_raw_callback(
+        self, callback: Callable[[str], Awaitable[None]]
+    ) -> None:
+        """Unregister a callback handler for raw telnet messages."""
+        self._raw_callbacks.remove(callback)
+
     def _process_event(self, message: str) -> None:
         """Process a realtime event."""
         _LOGGER.debug("Incoming Telnet message: %s", message)
         self._last_message_time = time.monotonic()
         if len(message) < 3:
             return
-        zone = MAIN_ZONE
 
         # Event is 2 characters
         event = self._get_event(message)
@@ -603,7 +644,11 @@ class DenonAVRTelnetApi:
             if parameter[0:3] == "MAX":
                 return
 
-        if event in ("Z2", "Z3"):
+        # Determine zone
+        zone = MAIN_ZONE
+        if event in ALL_ZONE_TELNET_EVENTS:
+            zone = ALL_ZONES
+        elif event in {"Z2", "Z3"}:
             if event == "Z2":
                 zone = ZONE2
             else:
@@ -620,10 +665,28 @@ class DenonAVRTelnetApi:
         if event not in TELNET_EVENTS:
             return
 
-        asyncio.create_task(self._async_run_callbacks(event, zone, parameter))
+        task = asyncio.create_task(
+            self._async_run_callbacks(message, event, zone, parameter)
+        )
+        self._callback_tasks.add(task)
+        task.add_done_callback(self._callback_tasks.discard)
+
+    async def _async_run_callbacks(
+        self, message: str, event: str, zone: str, parameter: str
+    ) -> None:
+        """Handle triggering the registered callbacks."""
+        for callback in self._raw_callbacks:
+            try:
+                await callback(message)
+            except Exception as err:  # pylint: disable=broad-except
+                # We don't want a single bad callback to trip up the
+                # whole system and prevent further execution
+                _LOGGER.error(
+                    "%s: Raw callback caused an unhandled exception %s",
+                    self.host,
+                    err,
+                )
 
-    async def _async_run_callbacks(self, event: str, zone: str, parameter: str) -> None:
-        """Handle triggering the registered callbacks for the event."""
         if event in self._callbacks.keys():
             for callback in self._callbacks[event]:
                 try:
@@ -637,8 +700,8 @@ class DenonAVRTelnetApi:
                         err,
                     )
 
-        if "ALL" in self._callbacks.keys():
-            for callback in self._callbacks["ALL"]:
+        if ALL_TELNET_EVENTS in self._callbacks.keys():
+            for callback in self._callbacks[ALL_TELNET_EVENTS]:
                 try:
                     await callback(zone, event, parameter)
                 except Exception as err:  # pylint: disable=broad-except
@@ -658,15 +721,47 @@ class DenonAVRTelnetApi:
                 return event
         return ""
 
-    def send_commands(self, *commands: str) -> bool:
+    async def _async_send_confirmation_callback(self, message: str) -> None:
+        """Confirm that the telnet command has been executed."""
+        if len(message) < 3:
+            return
+        command = self._send_confirmation_command
+        if self._get_event(message) == self._get_event(self._send_confirmation_command):
+            self._send_confirmation_command = ""
+            self._send_confirmation_event.set()
+            _LOGGER.debug("Command %s confirmed", command)
+
+    async def _async_send_command(self, command: str) -> None:
+        """Send one telnet command to the receiver."""
+        async with self._send_lock:
+            self._send_confirmation_command = command
+            self._send_confirmation_event.clear()
+            if not self.connected or not self.healthy:
+                raise AvrProcessingError(
+                    f"Error sending command {command}. Telnet connected: "
+                    f"{self.connected}, Connection healthy: {self.healthy}"
+                )
+            self._protocol.write(f"{command}\r")
+            try:
+                await asyncio.wait_for(
+                    self._send_confirmation_event.wait(),
+                    self._send_confirmation_timeout,
+                )
+            except asyncio.TimeoutError:
+                _LOGGER.info("Timeout waiting for confirmation of command: %s", command)
+            finally:
+                self._send_confirmation_command = ""
+
+    async def async_send_commands(self, *commands: str) -> None:
         """Send telnet commands to the receiver."""
-        if not self.connected:
-            return False
-        if not self.healthy:
-            return False
         for command in commands:
-            self._protocol.write("{}\r".format(command))
-        return True
+            await self._async_send_command(command)
+
+    def send_commands(self, *commands: str) -> None:
+        """Send telnet commands to the receiver."""
+        task = asyncio.create_task(self.async_send_commands(*commands))
+        self._send_tasks.add(task)
+        task.add_done_callback(self._send_tasks.discard)
 
     ##############
     # Properties #

denonavr/audyssey.py

@@ -8,7 +8,8 @@ This module implements the Audyssey settings of Denon AVR receivers.
 """
 
 import logging
-from typing import Hashable, List, Optional
+from collections.abc import Hashable
+from typing import List, Optional
 
 import attr
 
@@ -16,11 +17,14 @@ from .appcommand import AppCommandCmd, AppCommandCmdParam, AppCommands
 from .const import (
     DENON_ATTR_SETATTR,
     DYNAMIC_VOLUME_MAP,
-    DYNAMIC_VOLUME_MAP_LABELS,
+    DYNAMIC_VOLUME_MAP_LABELS_APPCOMMAND,
+    DYNAMIC_VOLUME_MAP_LABELS_TELNET,
     MULTI_EQ_MAP,
-    MULTI_EQ_MAP_LABELS,
+    MULTI_EQ_MAP_LABELS_APPCOMMAND,
+    MULTI_EQ_MAP_LABELS_TELNET,
     REF_LVL_OFFSET_MAP,
-    REF_LVL_OFFSET_MAP_LABELS,
+    REF_LVL_OFFSET_MAP_LABELS_APPCOMMAND,
+    REF_LVL_OFFSET_MAP_LABELS_TELNET,
 )
 from .exceptions import AvrCommandError, AvrProcessingError
 from .foundation import DenonAVRFoundation, convert_string_int_bool
@@ -129,13 +133,9 @@ class DenonAVRAudyssey(DenonAVRFoundation):
 
         try:
             if res.find("cmd").text != "OK":
-                raise AvrProcessingError(
-                    "SetAudyssey command {} failed".format(cmd.name)
-                )
+                raise AvrProcessingError(f"SetAudyssey command {cmd.name} failed")
         except AttributeError as err:
-            raise AvrProcessingError(
-                "SetAudyssey command {} failed".format(cmd.name)
-            ) from err
+            raise AvrProcessingError(f"SetAudyssey command {cmd.name} failed") from err
 
     ##############
     # Properties #
@@ -153,7 +153,9 @@ class DenonAVRAudyssey(DenonAVRFoundation):
     @property
     def reference_level_offset_setting_list(self) -> List[str]:
         """Return a list of available reference level offset settings."""
-        return list(REF_LVL_OFFSET_MAP_LABELS.keys())
+        if self._device.telnet_available:
+            return list(REF_LVL_OFFSET_MAP_LABELS_TELNET.keys())
+        return list(REF_LVL_OFFSET_MAP_LABELS_APPCOMMAND.keys())
 
     @property
     def dynamic_volume(self) -> Optional[str]:
@@ -163,7 +165,9 @@ class DenonAVRAudyssey(DenonAVRFoundation):
     @property
     def dynamic_volume_setting_list(self) -> List[str]:
         """Return a list of available Dynamic Volume settings."""
-        return list(DYNAMIC_VOLUME_MAP_LABELS.keys())
+        if self._device.telnet_available:
+            return list(DYNAMIC_VOLUME_MAP_LABELS_TELNET.keys())
+        return list(DYNAMIC_VOLUME_MAP_LABELS_APPCOMMAND.keys())
 
     @property
     def multi_eq(self) -> Optional[str]:
@@ -173,13 +177,19 @@ class DenonAVRAudyssey(DenonAVRFoundation):
     @property
     def multi_eq_setting_list(self) -> List[str]:
         """Return a list of available MultiEQ settings."""
-        return list(MULTI_EQ_MAP_LABELS.keys())
+        if self._device.telnet_available:
+            return list(MULTI_EQ_MAP_LABELS_TELNET.keys())
+        return list(MULTI_EQ_MAP_LABELS_APPCOMMAND.keys())
 
     ##########
     # Setter #
     ##########
     async def async_dynamiceq_off(self) -> None:
         """Turn DynamicEQ off."""
+        if self._device.telnet_available:
+            telnet_command = self._device.telnet_commands.command_dynamiceq + "OFF"
+            await self._device.telnet_api.async_send_commands(telnet_command)
+            return
         cmd = attr.evolve(
             AppCommands.SetAudysseyDynamicEQ,
             param_list=(AppCommandCmdParam(name="dynamiceq", text=0),),
@@ -188,6 +198,10 @@ class DenonAVRAudyssey(DenonAVRFoundation):
 
     async def async_dynamiceq_on(self) -> None:
         """Turn DynamicEQ on."""
+        if self._device.telnet_available:
+            telnet_command = self._device.telnet_commands.command_dynamiceq + "ON"
+            await self._device.telnet_api.async_send_commands(telnet_command)
+            return
         cmd = attr.evolve(
             AppCommands.SetAudysseyDynamicEQ,
             param_list=(AppCommandCmdParam(name="dynamiceq", text=1),),
@@ -196,9 +210,17 @@ class DenonAVRAudyssey(DenonAVRFoundation):
 
     async def async_set_multieq(self, value: str) -> None:
         """Set MultiEQ mode."""
-        setting = MULTI_EQ_MAP_LABELS.get(value)
+        if self._device.telnet_available:
+            setting = MULTI_EQ_MAP_LABELS_TELNET.get(value)
+            if setting is None:
+                raise AvrCommandError(f"Value {value} not known for MultiEQ")
+            telnet_command = self._device.telnet_commands.command_multieq + setting
+            await self._device.telnet_api.async_send_commands(telnet_command)
+            return
+
+        setting = MULTI_EQ_MAP_LABELS_APPCOMMAND.get(value)
         if setting is None:
-            raise AvrCommandError("Value {} not known for MultiEQ".format(value))
+            raise AvrCommandError(f"Value {value} not known for MultiEQ")
         cmd = attr.evolve(
             AppCommands.SetAudysseyMultiEQ,
             param_list=(AppCommandCmdParam(name="multeq", text=setting),),
@@ -212,11 +234,19 @@ class DenonAVRAudyssey(DenonAVRFoundation):
             raise AvrCommandError(
                 "Reference level could only be set when DynamicEQ is active"
             )
-        setting = REF_LVL_OFFSET_MAP_LABELS.get(value)
+        if self._device.telnet_available:
+            setting = REF_LVL_OFFSET_MAP_LABELS_TELNET.get(value)
+            if setting is None:
+                raise AvrCommandError(
+                    f"Value {value} not known for Reference level offset"
+                )
+            telnet_command = self._device.telnet_commands.command_reflevoffset + setting
+            await self._device.telnet_api.async_send_commands(telnet_command)
+            return
+
+        setting = REF_LVL_OFFSET_MAP_LABELS_APPCOMMAND.get(value)
         if setting is None:
-            raise AvrCommandError(
-                "Value {} not known for Reference level offset".format(value)
-            )
+            raise AvrCommandError(f"Value {value} not known for Reference level offset")
         cmd = attr.evolve(
             AppCommands.SetAudysseyReflevoffset,
             param_list=(AppCommandCmdParam(name="reflevoffset", text=setting),),
@@ -225,9 +255,17 @@ class DenonAVRAudyssey(DenonAVRFoundation):
 
     async def async_set_dynamicvol(self, value: str) -> None:
         """Set Dynamic Volume."""
-        setting = DYNAMIC_VOLUME_MAP_LABELS.get(value)
+        if self._device.telnet_available:
+            setting = DYNAMIC_VOLUME_MAP_LABELS_TELNET.get(value)
+            if setting is None:
+                raise AvrCommandError(f"Value {value} not known for Dynamic Volume")
+            telnet_command = self._device.telnet_commands.command_dynamicvol + setting
+            await self._device.telnet_api.async_send_commands(telnet_command)
+            return
+
+        setting = DYNAMIC_VOLUME_MAP_LABELS_APPCOMMAND.get(value)
         if setting is None:
-            raise AvrCommandError("Value {} not known for Dynamic Volume".format(value))
+            raise AvrCommandError(f"Value {value} not known for Dynamic Volume")
         cmd = attr.evolve(
             AppCommands.SetAudysseyDynamicvol,
             param_list=(AppCommandCmdParam(name="dynamicvol", text=setting),),