denonavr 0.11.2__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.2"
+__version__ = "0.11.6"
 
 
 async def async_discover():

denonavr/api.py

@@ -13,16 +13,31 @@ import logging
 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, Dict, Hashable, Optional, Tuple, cast
+from typing import (
+    Awaitable,
+    Callable,
+    Coroutine,
+    DefaultDict,
+    Dict,
+    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,
@@ -34,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,
 )
 
@@ -61,6 +73,16 @@ def get_default_async_client() -> httpx.AsyncClient:
     return httpx.AsyncClient()
 
 
+def telnet_event_map_factory() -> Dict[str, List]:
+    """Create telnet event map."""
+    event_map: DefaultDict[str, List] = defaultdict(list)
+    for event in TELNET_EVENTS:
+        event_map[event[0:2]].append(event)
+    for value in event_map.values():
+        value.sort(key=len, reverse=True)
+    return dict(event_map)
+
+
 @attr.s(auto_attribs=True, hash=False, on_setattr=DENON_ATTR_SETATTR)
 class DenonAVRApi:
     """Perform API calls to Denon AVR REST interface."""
@@ -107,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:
@@ -134,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:
@@ -159,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
@@ -176,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
@@ -201,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())
@@ -213,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())
@@ -247,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
@@ -333,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
 
 
@@ -352,12 +370,17 @@ class DenonAVRTelnetProtocol(asyncio.Protocol):
     @property
     def connected(self) -> bool:
         """Return True if transport is connected."""
-        return self.transport is not None
+        if self.transport is None:
+            return False
+        return not self.transport.is_closing()
 
     def write(self, data: str) -> None:
         """Write data to the transport."""
-        if self.transport is not None:
-            self.transport.write(data.encode("utf-8"))
+        if self.transport is None:
+            return
+        if self.transport.is_closing():
+            return
+        self.transport.write(data.encode("utf-8"))
 
     def close(self) -> None:
         """Close the connection."""
@@ -398,17 +421,37 @@ class DenonAVRTelnetApi:
     _reconnect_task: asyncio.Task = attr.ib(default=None)
     _monitor_handle: asyncio.TimerHandle = attr.ib(default=None)
     _protocol: DenonAVRTelnetProtocol = attr.ib(default=None)
-    _callbacks: Dict[str, Callable] = attr.ib(
+    _telnet_event_map: Dict[str, List] = attr.ib(
+        default=attr.Factory(telnet_event_map_factory)
+    )
+    _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."""
         _LOGGER.debug("%s: telnet connecting", self.host)
         async with self._connect_lock:
-            if self.connected is True:
+            if self.connected:
                 return
             await self._async_establish_connection()
 
@@ -428,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."""
@@ -468,7 +527,7 @@ class DenonAVRTelnetApi:
             _LOGGER.info(
                 "%s: Keep alive failed, disconnecting and reconnecting", self.host
             )
-            if self._protocol:
+            if self._protocol is not None:
                 self._protocol.close()
             self._handle_disconnected()
             return
@@ -511,7 +570,7 @@ class DenonAVRTelnetApi:
         """Reconnect to the receiver asynchronously."""
         backoff = 0.5
 
-        while self._connection_enabled is True and not self.healthy:
+        while self._connection_enabled and not self.healthy:
             async with self._connect_lock:
                 try:
                     await self._async_establish_connection()
@@ -539,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] = []
@@ -554,18 +613,29 @@ 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 = message[0:2]
+        event = self._get_event(message)
         # Parameter is the remaining characters
-        parameter = message[2:]
+        parameter = message[len(event) :]
 
         if event == "MV":
             # This seems undocumented by Denon and appears to basically be a
@@ -574,29 +644,49 @@ 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:
                 zone = ZONE3
 
-            if parameter in ("ON", "OFF"):
-                event = "PW"
-            elif parameter in TELNET_SOURCES:
+            if parameter in TELNET_SOURCES:
                 event = "SI"
             elif parameter.isdigit():
                 event = "MV"
-            elif parameter[0:2] in TELNET_EVENTS:
-                event = parameter[0:2]
-                parameter = parameter[2:]
+            elif self._get_event(parameter):
+                event = self._get_event(parameter)
+                parameter = parameter[len(event) :]
 
         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:
@@ -610,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
@@ -623,10 +713,55 @@ class DenonAVRTelnetApi:
                         err,
                     )
 
-    def send_commands(self, *commands: str) -> None:
+    def _get_event(self, message: str) -> str:
+        """Get event of a telnet message."""
+        events = self._telnet_event_map.get(message[0:2], [""])
+        for event in events:
+            if message.startswith(event):
+                return event
+        return ""
+
+    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."""
         for command in commands:
-            self._protocol.write("{}\r".format(command))
+            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 #
@@ -637,6 +772,6 @@ class DenonAVRTelnetApi:
         return self._connection_enabled
 
     @property
-    def healthy(self) -> Optional[bool]:
+    def healthy(self) -> bool:
         """Return True if telnet connection is healthy."""
         return self._protocol is not None and self._protocol.connected

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
@@ -96,7 +100,7 @@ class DenonAVRAudyssey(DenonAVRFoundation):
     ) -> None:
         """Update Audyssey asynchronously."""
         # Ensure instance is setup before updating
-        if self._is_setup is False:
+        if not self._is_setup:
             self.setup()
 
         # Update state
@@ -106,7 +110,13 @@ class DenonAVRAudyssey(DenonAVRFoundation):
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ):
         """Update Audyssey status of device."""
-        if self._device.use_avr_2016_update is True:
+        if self._device.use_avr_2016_update is None:
+            raise AvrProcessingError(
+                "Device is not setup correctly, update method not set"
+            )
+
+        # Audyssey is only available for avr 2016 update
+        if self._device.use_avr_2016_update:
             await self.async_update_attrs_appcommand(
                 self.appcommand0300_attrs,
                 appcommand0300=True,
@@ -114,13 +124,6 @@ class DenonAVRAudyssey(DenonAVRFoundation):
                 cache_id=cache_id,
                 ignore_missing_response=True,
             )
-        elif self._device.use_avr_2016_update is False:
-            # Not available
-            pass
-        else:
-            raise AvrProcessingError(
-                "Device is not setup correctly, update method not set"
-            )
 
     async def _async_set_audyssey(self, cmd: AppCommandCmd) -> None:
         """Set Audyssey parameter."""
@@ -130,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 #
@@ -154,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]:
@@ -164,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]:
@@ -174,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),),
@@ -189,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),),
@@ -197,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),),
@@ -209,15 +230,23 @@ class DenonAVRAudyssey(DenonAVRFoundation):
     async def async_set_reflevoffset(self, value: str) -> None:
         """Set Reference Level Offset."""
         # Reference level offset can only be used with DynamicEQ
-        if self._dynamiceq is False:
+        if not self._dynamiceq:
             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),),
@@ -226,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),),
@@ -237,7 +274,7 @@ class DenonAVRAudyssey(DenonAVRFoundation):
 
     async def async_toggle_dynamic_eq(self) -> None:
         """Toggle DynamicEQ."""
-        if self._dynamiceq is True:
+        if self._dynamiceq:
             await self.async_dynamiceq_off()
         else:
             await self.async_dynamiceq_on()