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

denonavr/const.py

@@ -45,6 +45,31 @@ ReceiverURLs = namedtuple(
         "command_play",
     ],
 )
+TelnetCommands = namedtuple(
+    "TelnetCommands",
+    [
+        "command_sel_src",
+        "command_fav_src",
+        "command_power_on",
+        "command_power_standby",
+        "command_volume_up",
+        "command_volume_down",
+        "command_set_volume",
+        "command_mute_on",
+        "command_mute_off",
+        "command_sel_sound_mode",
+        "command_set_all_zone_stereo",
+        "command_pause",
+        "command_play",
+        "command_multieq",
+        "command_dynamiceq",
+        "command_reflevoffset",
+        "command_dynamicvol",
+        "command_tonecontrol",
+        "command_bass",
+        "command_treble",
+    ],
+)
 
 # AVR-X search patterns
 DEVICEINFO_AVR_X_PATTERN = re.compile(
@@ -95,7 +120,7 @@ CHANGE_INPUT_MAPPING = {
     "Spotify": "SPOTIFY",
 }
 
-TELNET_SOURCES = [
+TELNET_SOURCES = {
     "CD",
     "PHONO",
     "TUNER",
@@ -109,6 +134,7 @@ TELNET_SOURCES = [
     "NET",
     "PANDORA",
     "SIRIUSXM",
+    "SOURCE",
     "LASTFM",
     "FLICKR",
     "IRADIO",
@@ -126,7 +152,7 @@ TELNET_SOURCES = [
     "USB/IPOD",
     "USB DIRECT",
     "IPOD DIRECT",
-]
+}
 
 TELNET_MAPPING = {
     "FAVORITES": "Favorites",
@@ -167,6 +193,7 @@ SOUND_MODE_MAPPING = {
         "DOLBY PL2 CINEMA",
         "DOLBY PL2 C",
         "DOLBY PL2 X MOVIE",
+        "DOLBY PL2 MOVIE",
     ],
     "GAME": [
         "PLII GAME",
@@ -174,6 +201,7 @@ SOUND_MODE_MAPPING = {
         "DOLBY PL2 GAME",
         "DOLBY PL2 G",
         "DOLBY PL2 X GAME",
+        "DOLBY PLII GAME",
     ],
     "AUTO": ["None"],
     "STANDARD": ["None2"],
@@ -188,11 +216,14 @@ SOUND_MODE_MAPPING = {
     "DOLBY DIGITAL": [
         "DOLBY DIGITAL",
         "DOLBY D + DOLBY SURROUND",
+        "DOLBY D+DS",
+        "DOLBY D+ +DS",
         "DOLBY DIGITAL +",
         "STANDARD(DOLBY)",
         "DOLBY SURROUND",
         "DOLBY D + +DOLBY SURROUND",
         "NEURAL",
+        "NEURAL:X",
         "DOLBY HD",
         "DOLBY HD + DOLBY SURROUND",
         "MULTI IN + DSUR",
@@ -208,11 +239,15 @@ SOUND_MODE_MAPPING = {
         "DOLBY AUDIO - TRUEHD + DSUR",
         "DOLBY AUDIO - DOLBY TRUEHD",
         "DOLBY AUDIO - TRUEHD + NEURAL:X",
+        "DOLBY AUDIO - DD + NEURAL:X",
         "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",
@@ -230,7 +265,8 @@ SOUND_MODE_MAPPING = {
         "DTS-HD + DSUR",
         "DTS:X MSTR",
     ],
-    "AURO3D": ["AURO-3D", "AURO-2D SURROUND"],
+    "AURO3D": ["AURO-3D"],
+    "AURO2DSURR": ["AURO-2D SURROUND"],
     "MCH STEREO": [
         "MULTI CH STEREO",
         "MULTI_CH_STEREO",
@@ -391,23 +427,146 @@ ZONE3_URLS = ReceiverURLs(
     command_play=COMMAND_PLAY,
 )
 
-# Telnet Commands
-TELNET_EVENTS = {"HD", "MS", "MU", "MV", "NS", "PS", "PW", "SI", "SS", "TF"}
+# Telnet Events
+ALL_TELNET_EVENTS = "ALL"
+TELNET_EVENTS = {
+    "CV",
+    "DC",
+    "DIM",
+    "ECO",
+    "HD",
+    "MN",
+    "MS",
+    "MU",
+    "MV",
+    "NS",
+    "NSA",
+    "NSE",
+    "OP",
+    "PS",
+    "PV",
+    "PW",
+    "RM",
+    "SD",
+    "SI",
+    "SLP",
+    "SR",
+    "SS",
+    "STBY",
+    "SV",
+    "SY",
+    "TF",
+    "TM",
+    "TP",
+    "TR",
+    "UG",
+    "VS",
+    "ZM",
+    "Z2",
+    "Z3",
+}
+ALL_ZONE_TELNET_EVENTS = {
+    "DIM",
+    "HD",
+    "NS",
+    "NSA",
+    "NSE",
+    "MN",
+    "PW",
+    "RM",
+    "SY",
+    "TF",
+    "TM",
+    "TP",
+    "TR",
+    "UG",
+}
+
+DENONAVR_TELNET_COMMANDS = TelnetCommands(
+    command_sel_src="SI",
+    command_fav_src="ZM",
+    command_power_on="ZMON",
+    command_power_standby="ZMOFF",
+    command_volume_up="MVUP",
+    command_volume_down="MVDOWN",
+    command_set_volume="MV{volume:02d}",
+    command_mute_on="MUON",
+    command_mute_off="MUOFF",
+    command_sel_sound_mode="MS",
+    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(
+    command_sel_src="Z2",
+    command_fav_src="Z2",
+    command_power_on="Z2ON",
+    command_power_standby="Z2OFF",
+    command_volume_up="Z2UP",
+    command_volume_down="Z2DOWN",
+    command_set_volume="Z2{volume:02d}",
+    command_mute_on="Z2MUON",
+    command_mute_off="Z2MUOFF",
+    command_sel_sound_mode="MS",
+    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(
+    command_sel_src="Z3",
+    command_fav_src="Z3",
+    command_power_on="Z3ON",
+    command_power_standby="Z3OFF",
+    command_volume_up="Z3UP",
+    command_volume_down="Z3DOWN",
+    command_set_volume="Z3{volume:02d}",
+    command_mute_on="Z3MUON",
+    command_mute_off="Z3MUOFF",
+    command_sel_sound_mode="MS",
+    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
 POWER_ON = "ON"
 POWER_OFF = "OFF"
 POWER_STANDBY = "STANDBY"
+POWER_STATES = {POWER_ON, POWER_OFF, POWER_STANDBY}
 STATE_ON = "on"
 STATE_OFF = "off"
 STATE_PLAYING = "playing"
 STATE_PAUSED = "paused"
 
 # Zones
+ALL_ZONES = "All"
 MAIN_ZONE = "Main"
 ZONE2 = "Zone2"
 ZONE3 = "Zone3"
-VALID_ZONES = [MAIN_ZONE, ZONE2, ZONE3]
+VALID_ZONES = {MAIN_ZONE, ZONE2, ZONE3}
 
 # Setup additional zones
 NO_ZONES = None
@@ -420,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/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.
@@ -48,24 +49,18 @@ def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[...,
             _LOGGER.debug("HTTP status error on request %s", err.request, exc_info=True)
             # Separate handling of 403 errors
             if err.response.status_code == 403:
-                raise AvrForbiddenError(
-                    "HTTPStatusError: {}".format(err), err.request
-                ) from err
-            raise AvrRequestError(
-                "HTTPStatusError: {}".format(err), err.request
-            ) from err
+                raise AvrForbiddenError(f"HTTPStatusError: {err}", err.request) from err
+            raise AvrRequestError(f"HTTPStatusError: {err}", err.request) from err
         except httpx.TimeoutException as err:
             _LOGGER.debug(
                 "HTTP timeout exception on request %s", err.request, exc_info=True
             )
-            raise AvrTimoutError(
-                "TimeoutException: {}".format(err), err.request
-            ) from err
+            raise AvrTimoutError(f"TimeoutException: {err}", err.request) from err
         except httpx.NetworkError as err:
             _LOGGER.debug(
                 "Network error exception on request %s", err.request, exc_info=True
             )
-            raise AvrNetworkError("NetworkError: {}".format(err), err.request) from err
+            raise AvrNetworkError(f"NetworkError: {err}", err.request) from err
         except httpx.RemoteProtocolError as err:
             _LOGGER.debug(
                 "Remote protocol error exception on request %s",
@@ -73,7 +68,7 @@ def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[...,
                 exc_info=True,
             )
             raise AvrInvalidResponseError(
-                "RemoteProtocolError: {}".format(err), err.request
+                f"RemoteProtocolError: {err}", err.request
             ) from err
         except (
             ET.ParseError,
@@ -85,50 +80,43 @@ def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[...,
                 "Defusedxml parse error on request %s", (args, kwargs), exc_info=True
             )
             raise AvrInvalidResponseError(
-                "XMLParseError: {}".format(err), (args, kwargs)
+                f"XMLParseError: {err}", (args, kwargs)
             ) from err
 
     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.
@@ -141,13 +129,11 @@ def run_async_synchronously(async_func: Coroutine) -> Callable:
     def decorator(func: Callable):
         # Check if function is a coroutine
         if not inspect.iscoroutinefunction(async_func):
-            raise AttributeError(
-                "Function {} is not a coroutine function".format(async_func)
-            )
+            raise AttributeError(f"Function {async_func} is not a coroutine function")
         # Check if the signature of both functions is equal
         if inspect.signature(func) != inspect.signature(async_func):
             raise AttributeError(
-                "Functions {} and {} have different signatures".format(func, async_func)
+                f"Functions {func} and {async_func} have different signatures"
             )
 
         @wraps(func)

denonavr/denonavr.py

@@ -124,7 +124,7 @@ class DenonAVR(DenonAVRFoundation):
             # Name either set explicitly or name of Main Zone with suffix
             zonename = None
             if zname is None and self._name is not None:
-                zonename = "{} {}".format(self._name, zone)
+                zonename = f"{self._name} {zone}"
             zone_device = attr.evolve(self._device, zone=zone)
             zone_inst = DenonAVR(
                 host=self._host,
@@ -167,7 +167,7 @@ class DenonAVR(DenonAVRFoundation):
         Method executes the update method for the current receiver type.
         """
         # Ensure that the device is setup
-        if self._is_setup is False:
+        if not self._is_setup:
             await self.async_setup()
 
         # Create a cache id for this global update
@@ -226,6 +226,10 @@ class DenonAVR(DenonAVRFoundation):
     def send_get_command(self, request: str) -> str:
         """Send HTTP GET command to Denon AVR receiver...for compatibility."""
 
+    async def async_send_telnet_commands(self, *commands: str) -> None:
+        """Send telnet commands to the receiver."""
+        await self._device.telnet_api.async_send_commands(*commands)
+
     def send_telnet_commands(self, *commands: str) -> None:
         """Send telnet commands to the receiver."""
         self._device.telnet_api.send_commands(*commands)
@@ -435,13 +439,18 @@ class DenonAVR(DenonAVRFoundation):
             return None
         return self._device.receiver.type
 
+    @property
+    def telnet_available(self) -> bool:
+        """Return True if telnet is connected and healthy."""
+        return self._device.telnet_available
+
     @property
     def telnet_connected(self) -> bool:
         """Return True if telnet is connected."""
         return self._device.telnet_api.connected
 
     @property
-    def telnet_healthy(self) -> Optional[bool]:
+    def telnet_healthy(self) -> bool:
         """Return True if telnet connection is healthy."""
         return self._device.telnet_api.healthy
 
@@ -450,6 +459,16 @@ class DenonAVR(DenonAVRFoundation):
         """Indicate if all inputs are shown or just active one."""
         return self._show_all_inputs
 
+    @property
+    def tone_control_status(self) -> Optional[bool]:
+        """Return value of tone control status."""
+        return self.tonecontrol.tone_control_status
+
+    @property
+    def tone_control_adjust(self) -> Optional[bool]:
+        """Return value of tone control adjust."""
+        return self.tonecontrol.tone_control_adjust
+
     @property
     def bass(self) -> Optional[int]:
         """Return value of bass."""
@@ -505,10 +524,6 @@ class DenonAVR(DenonAVRFoundation):
         """Return a list of available MultiEQ settings."""
         return self.audyssey.multi_eq_setting_list
 
-    async def async_dynamic_eq_off(self) -> None:
-        """Turn DynamicEQ off."""
-        await self.audyssey.async_dynamiceq_off()
-
     ##########
     # Setter #
     ##########
@@ -525,6 +540,10 @@ class DenonAVR(DenonAVRFoundation):
             raise AvrCommandError("Provided object is not callable")
         self._device.api.async_client_getter = async_client_getter
 
+    async def async_dynamic_eq_off(self) -> None:
+        """Turn DynamicEQ off."""
+        await self.audyssey.async_dynamiceq_off()
+
     @run_async_synchronously(async_func=async_dynamic_eq_off)
     def dynamic_eq_off(self) -> None:
         """Turn DynamicEQ off."""
@@ -545,6 +564,30 @@ class DenonAVR(DenonAVRFoundation):
     def toggle_dynamic_eq(self) -> None:
         """Toggle DynamicEQ."""
 
+    async def async_set_multieq(self, value: str) -> None:
+        """Set MultiEQ mode."""
+        await self.audyssey.async_set_multieq(value)
+
+    @run_async_synchronously(async_func=async_set_multieq)
+    def set_multieq(self, value: str) -> None:
+        """Set MultiEQ mode."""
+
+    async def async_set_reflevoffset(self, value: str) -> None:
+        """Set Reference Level Offset."""
+        await self.audyssey.async_set_reflevoffset(value)
+
+    @run_async_synchronously(async_func=async_set_reflevoffset)
+    def set_reflevoffset(self, value: str) -> None:
+        """Set Reference Level Offset."""
+
+    async def async_set_dynamicvol(self, value: str) -> None:
+        """Set Dynamic Volume."""
+        await self.audyssey.async_set_dynamicvol(value)
+
+    @run_async_synchronously(async_func=async_set_dynamicvol)
+    def set_dynamicvol(self, value: str) -> None:
+        """Set Dynamic Volume."""
+
     async def async_set_input_func(self, input_func: str) -> None:
         """
         Set input_func of device.