denonavr 0.11.4__tar.gz → 0.11.6__tar.gz

{denonavr-0.11.4 → denonavr-0.11.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: denonavr
-Version: 0.11.4
+Version: 0.11.6
 Summary: Automation Library for Denon AVR receivers
 Author-email: Oliver Goetz <scarface@mywoh.de>
 License: MIT
@@ -19,12 +19,14 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown; charset=UTF-8
 License-File: LICENSE
 Requires-Dist: asyncstdlib>=3.10.2
 Requires-Dist: attrs>=21.2.0
 Requires-Dist: defusedxml>=0.7.1
+Requires-Dist: ftfy>=6.1.1
 Requires-Dist: httpx>=0.23.1
 Requires-Dist: netifaces>=0.11.0
 Requires-Dist: async-timeout>=4.0.2; python_version < "3.11"
@@ -58,7 +60,7 @@ In addition to retrieving the current device status via HTTP calls, this version
 
 As of version 0.10.0 and newer, the `denonavr` library has switched to using`async` methods to interact with Denon receivers.
 
-Legacy synchronous methods are still availlable to avoid breaking existing implementations, but may be deprecated in the future.  Switching to `async` methods is recommended.  The existing sync methods are inefficient because they use the corresponding async methods by starting and stopping its own `asyncio` loop for each command.
+Legacy synchronous methods are still available to avoid breaking existing implementations, but may be deprecated in the future.  Switching to `async` methods is recommended.  The existing sync methods are inefficient because they use the corresponding async methods by starting and stopping its own `asyncio` loop for each command.
 
 ### Other changes:
 
@@ -129,8 +131,8 @@ The `asyncio` library should automatically be imported in the REPL.  Import the
 ```
 ### Sound
 ```
->>> await d.async_mute_on(True)
->>> await d.async_mute_off(False)
+>>> await d.async_mute(True)
+>>> await d.async_mute(False)
 ```
 
 ### Other methods

{denonavr-0.11.4 → denonavr-0.11.6}/README.md

@@ -17,7 +17,7 @@ In addition to retrieving the current device status via HTTP calls, this version
 
 As of version 0.10.0 and newer, the `denonavr` library has switched to using`async` methods to interact with Denon receivers.
 
-Legacy synchronous methods are still availlable to avoid breaking existing implementations, but may be deprecated in the future.  Switching to `async` methods is recommended.  The existing sync methods are inefficient because they use the corresponding async methods by starting and stopping its own `asyncio` loop for each command.
+Legacy synchronous methods are still available to avoid breaking existing implementations, but may be deprecated in the future.  Switching to `async` methods is recommended.  The existing sync methods are inefficient because they use the corresponding async methods by starting and stopping its own `asyncio` loop for each command.
 
 ### Other changes:
 
@@ -88,8 +88,8 @@ The `asyncio` library should automatically be imported in the REPL.  Import the
 ```
 ### Sound
 ```
->>> await d.async_mute_on(True)
->>> await d.async_mute_off(False)
+>>> await d.async_mute(True)
+>>> await d.async_mute(False)
 ```
 
 ### Other methods

{denonavr-0.11.4 → denonavr-0.11.6}/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.4"
+__version__ = "0.11.6"
 
 
 async def async_discover():

{denonavr-0.11.4 → denonavr-0.11.6}/denonavr/api.py

@@ -14,22 +14,23 @@ 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
@@ -48,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,
 )
 
@@ -179,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
@@ -196,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
@@ -357,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
 
 
@@ -430,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."""
@@ -478,7 +489,25 @@ class DenonAVRTelnetApi:
         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."""
@@ -584,6 +613,18 @@ 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)
@@ -624,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:
@@ -662,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(f"{command}\r")
-        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-0.11.4 → denonavr-0.11.6}/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
@@ -149,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]:
@@ -159,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]:
@@ -169,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),),
@@ -184,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),),
@@ -192,7 +210,15 @@ 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(f"Value {value} not known for MultiEQ")
         cmd = attr.evolve(
@@ -208,7 +234,17 @@ 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(f"Value {value} not known for Reference level offset")
         cmd = attr.evolve(
@@ -219,7 +255,15 @@ 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(f"Value {value} not known for Dynamic Volume")
         cmd = attr.evolve(

{denonavr-0.11.4 → denonavr-0.11.6}/denonavr/const.py

@@ -61,6 +61,13 @@ TelnetCommands = namedtuple(
         "command_set_all_zone_stereo",
         "command_pause",
         "command_play",
+        "command_multieq",
+        "command_dynamiceq",
+        "command_reflevoffset",
+        "command_dynamicvol",
+        "command_tonecontrol",
+        "command_bass",
+        "command_treble",
     ],
 )
 
@@ -186,6 +193,7 @@ SOUND_MODE_MAPPING = {
         "DOLBY PL2 CINEMA",
         "DOLBY PL2 C",
         "DOLBY PL2 X MOVIE",
+        "DOLBY PL2 MOVIE",
     ],
     "GAME": [
         "PLII GAME",
@@ -193,6 +201,7 @@ SOUND_MODE_MAPPING = {
         "DOLBY PL2 GAME",
         "DOLBY PL2 G",
         "DOLBY PL2 X GAME",
+        "DOLBY PLII GAME",
     ],
     "AUTO": ["None"],
     "STANDARD": ["None2"],
@@ -208,6 +217,7 @@ SOUND_MODE_MAPPING = {
         "DOLBY DIGITAL",
         "DOLBY D + DOLBY SURROUND",
         "DOLBY D+DS",
+        "DOLBY D+ +DS",
         "DOLBY DIGITAL +",
         "STANDARD(DOLBY)",
         "DOLBY SURROUND",
@@ -233,9 +243,11 @@ SOUND_MODE_MAPPING = {
         "DOLBY AUDIO - DD + DSUR",
         "DOLBY AUDIO - DD+   + NEURAL:X",
         "DOLBY AUDIO - DD+   + DSUR",
+        "DOLBY AUDIO-DD+ +DSUR",
         "DOLBY AUDIO - DOLBY DIGITAL",
         "DOLBY AUDIO-DSUR",
         "DOLBY AUDIO-DD+DSUR",
+        "DOLBY PRO LOGIC",
     ],
     "DTS SURROUND": [
         "DTS SURROUND",
@@ -484,6 +496,13 @@ DENONAVR_TELNET_COMMANDS = TelnetCommands(
     command_set_all_zone_stereo="MN",
     command_pause="NS9B",
     command_play="NS9A",
+    command_multieq="PSMULTEQ:",
+    command_dynamiceq="PSDYNEQ ",
+    command_reflevoffset="PSREFLEV ",
+    command_dynamicvol="PSDYNVOL ",
+    command_tonecontrol="PSTONE CTRL ",
+    command_bass="PSBAS ",
+    command_treble="PSTRE ",
 )
 
 ZONE2_TELNET_COMMANDS = TelnetCommands(
@@ -500,6 +519,13 @@ ZONE2_TELNET_COMMANDS = TelnetCommands(
     command_set_all_zone_stereo="MN",
     command_pause="NS9B",
     command_play="NS9A",
+    command_multieq="PSMULTEQ:",
+    command_dynamiceq="PSDYNEQ ",
+    command_reflevoffset="PSREFLEV ",
+    command_dynamicvol="PSDYNVOL ",
+    command_tonecontrol="PSTONE CTRL ",
+    command_bass="PSBAS ",
+    command_treble="PSTRE ",
 )
 
 ZONE3_TELNET_COMMANDS = TelnetCommands(
@@ -516,6 +542,13 @@ ZONE3_TELNET_COMMANDS = TelnetCommands(
     command_set_all_zone_stereo="MN",
     command_pause="NS9B",
     command_play="NS9A",
+    command_multieq="PSMULTEQ:",
+    command_dynamiceq="PSDYNEQ ",
+    command_reflevoffset="PSREFLEV ",
+    command_dynamicvol="PSDYNVOL ",
+    command_tonecontrol="PSTONE CTRL ",
+    command_bass="PSBAS ",
+    command_treble="PSTRE ",
 )
 
 # States
@@ -546,11 +579,41 @@ APPCOMMAND_CMD_TEXT = "cmd_text"
 APPCOMMAND_NAME = "name"
 
 # Audyssey parameter
-MULTI_EQ_MAP = {"0": "Off", "1": "Flat", "2": "L/R Bypass", "3": "Reference"}
-MULTI_EQ_MAP_LABELS = {(value, key) for key, value in MULTI_EQ_MAP.items()}
+MULTI_EQ_MAP_APPCOMMAND = {"0": "Off", "1": "Flat", "2": "L/R Bypass", "3": "Reference"}
+MULTI_EQ_MAP_TELNET = {
+    "OFF": "Off",
+    "FLAT": "Flat",
+    "BYP.LR": "L/R Bypass",
+    "AUDYSSEY": "Reference",
+    "MANUAL": "Manual",
+}
+MULTI_EQ_MAP = {**MULTI_EQ_MAP_APPCOMMAND, **MULTI_EQ_MAP_TELNET}
+MULTI_EQ_MAP_LABELS_APPCOMMAND = {
+    value: key for key, value in MULTI_EQ_MAP_APPCOMMAND.items()
+}
+MULTI_EQ_MAP_LABELS_TELNET = {value: key for key, value in MULTI_EQ_MAP_TELNET.items()}
 
-REF_LVL_OFFSET_MAP = {"0": "0dB", "1": "+5dB", "2": "+10dB", "3": "+15dB"}
-REF_LVL_OFFSET_MAP_LABELS = {(value, key) for key, value in REF_LVL_OFFSET_MAP.items()}
+REF_LVL_OFFSET_MAP_APPCOMMAND = {"0": "0dB", "1": "+5dB", "2": "+10dB", "3": "+15dB"}
+REF_LVL_OFFSET_MAP_TELNET = {"0": "0dB", "5": "+5dB", "10": "+10dB", "15": "+15dB"}
+REF_LVL_OFFSET_MAP = {**REF_LVL_OFFSET_MAP_APPCOMMAND, **REF_LVL_OFFSET_MAP_TELNET}
+REF_LVL_OFFSET_MAP_LABELS_APPCOMMAND = {
+    value: key for key, value in REF_LVL_OFFSET_MAP_APPCOMMAND.items()
+}
+REF_LVL_OFFSET_MAP_LABELS_TELNET = {
+    value: key for key, value in REF_LVL_OFFSET_MAP_TELNET.items()
+}
 
-DYNAMIC_VOLUME_MAP = {"0": "Off", "1": "Light", "2": "Medium", "3": "Heavy"}
-DYNAMIC_VOLUME_MAP_LABELS = {(value, key) for key, value in DYNAMIC_VOLUME_MAP.items()}
+DYNAMIC_VOLUME_MAP_APPCOMMAND = {"0": "Off", "1": "Light", "2": "Medium", "3": "Heavy"}
+DYNAMIC_VOLUME_MAP_TELNET = {
+    "OFF": "Off",
+    "LIT": "Light",
+    "MED": "Medium",
+    "HEV": "Heavy",
+}
+DYNAMIC_VOLUME_MAP = {**DYNAMIC_VOLUME_MAP_APPCOMMAND, **DYNAMIC_VOLUME_MAP_TELNET}
+DYNAMIC_VOLUME_MAP_LABELS_APPCOMMAND = {
+    value: key for key, value in DYNAMIC_VOLUME_MAP_APPCOMMAND.items()
+}
+DYNAMIC_VOLUME_MAP_LABELS_TELNET = {
+    value: key for key, value in DYNAMIC_VOLUME_MAP_TELNET.items()
+}

{denonavr-0.11.4 → denonavr-0.11.6}/denonavr/decorators.py

@@ -16,6 +16,7 @@ from functools import wraps
 from typing import Callable, Coroutine, TypeVar
 
 import httpx
+from asyncstdlib import lru_cache
 from defusedxml import DefusedXmlException
 from defusedxml.ElementTree import ParseError
 
@@ -34,7 +35,7 @@ AnyT = TypeVar("AnyT")
 
 def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[..., AnyT]:
     """
-    Handle exceptions raised when calling an Denon AVR endpoint asynchronously.
+    Handle exceptions raised when calling a Denon AVR endpoint asynchronously.
 
     The decorated function must either have a string variable as second
     argument or as "request" keyword argument.
@@ -85,44 +86,37 @@ def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[...,
     return wrapper
 
 
-def cache_clear_on_exception(func: Callable[..., AnyT]) -> Callable[..., AnyT]:
+def cache_result(func: Callable[..., AnyT]) -> Callable[..., AnyT]:
     """
-    Decorate a function to clear lru_cache if an exception occurs.
+    Decorate a function to cache its results with an lru_cache of maxsize 16.
 
-    The decorator must be placed right before the @lru_cache decorator.
-    It prevents memory leaks in home-assistant when receiver instances are
-    created and deleted right away in case the device is offline on setup.
+    This decorator also sets an "cache_id" keyword argument if it is not set yet.
+    When an exception occurs it clears lru_cache to prevent memory leaks in
+    home-assistant when receiver instances are created and deleted right
+    away in case the device is offline on setup.
     """
+    if inspect.signature(func).parameters.get("cache_id") is None:
+        raise AttributeError(
+            f"Function {func} does not have a 'cache_id' keyword parameter"
+        )
+
+    lru_decorator = lru_cache(maxsize=16)
+    cached_func = lru_decorator(func)
 
     @wraps(func)
     async def wrapper(*args, **kwargs):
+        if kwargs.get("cache_id") is None:
+            kwargs["cache_id"] = time.time()
         try:
-            return await func(*args, **kwargs)
+            return await cached_func(*args, **kwargs)
         except Exception as err:
             _LOGGER.debug("Exception %s raised, clearing cache", err)
-            func.cache_clear()
+            cached_func.cache_clear()
             raise
 
     return wrapper
 
 
-def set_cache_id(func: Callable[..., AnyT]) -> Callable[..., AnyT]:
-    """
-    Decorate a function to add cache_id keyword argument if it is not present.
-
-    The function must be called with a fix cache_id keyword argument to be able
-    to get cached data. This prevents accidential caching of a function result.
-    """
-
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        if kwargs.get("cache_id") is None:
-            kwargs["cache_id"] = time.time()
-        return func(*args, **kwargs)
-
-    return wrapper
-
-
 def run_async_synchronously(async_func: Coroutine) -> Callable:
     """
     Decorate to run the configured asynchronous function synchronously instead.