denonavr 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

denonavr/foundation.py

@@ -39,7 +39,10 @@ from .const import (
     DIMMER_MODE_MAP_LABELS,
     ECO_MODE_MAP,
     ECO_MODE_MAP_LABELS,
+    HDMI_OUTPUT_MAP,
     HDMI_OUTPUT_MAP_LABELS,
+    ILLUMINATION_MAP,
+    ILLUMINATION_MAP_LABELS,
     MAIN_ZONE,
     POWER_STATES,
     SETTINGS_MENU_STATES,
@@ -60,6 +63,7 @@ from .const import (
     EcoModes,
     HDMIAudioDecodes,
     HDMIOutputs,
+    Illuminations,
     PanelLocks,
     ReceiverType,
     ReceiverURLs,
@@ -153,6 +157,7 @@ class DenonAVRDeviceInfo:
     _dimmer: Optional[str] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
+    _dimmer_modes = get_args(DimmerModes)
     _auto_standby: Optional[str] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
@@ -166,9 +171,11 @@ class DenonAVRDeviceInfo:
     _eco_mode: Optional[str] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
+    _eco_modes = get_args(EcoModes)
     _hdmi_output: Optional[str] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
+    _hdmi_outputs = get_args(HDMIOutputs)
     _hdmi_audio_decode: Optional[str] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
@@ -216,6 +223,13 @@ class DenonAVRDeviceInfo:
     _headphone_eq: Optional[bool] = attr.ib(
         converter=attr.converters.optional(convert_on_off_bool), default=None
     )
+    _illumination: Optional[str] = attr.ib(
+        converter=attr.converters.optional(str), default=None
+    )
+    _illuminations = get_args(Illuminations)
+    _auto_lip_sync: Optional[bool] = attr.ib(
+        converter=attr.converters.optional(convert_on_off_bool), default=None
+    )
     _is_setup: bool = attr.ib(converter=bool, default=False, init=False)
     _allow_recovery: bool = attr.ib(converter=bool, default=True, init=True)
     _setup_lock: asyncio.Lock = attr.ib(default=attr.Factory(asyncio.Lock))
@@ -235,16 +249,12 @@ class DenonAVRDeviceInfo:
         else:
             raise ValueError(f"Invalid zone {self.zone}")
 
-    async def _async_power_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _power_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a power change event."""
         if self.zone == zone and parameter in POWER_STATES:
             self._power = parameter
 
-    async def _async_settings_menu_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _settings_menu_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a settings menu event."""
         if (
             event == "MN"
@@ -253,23 +263,17 @@ class DenonAVRDeviceInfo:
         ):
             self._settings_menu = parameter[4:]
 
-    async def _async_dimmer_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _dimmer_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a dimmer change event."""
         if event == "DIM" and parameter[1:] in DIMMER_MODE_MAP_LABELS:
             self._dimmer = DIMMER_MODE_MAP_LABELS[parameter[1:]]
 
-    async def _async_auto_standby_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _auto_standby_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a auto standby change event."""
         if zone == "Main" and event == "STBY":
             self._auto_standby = parameter
 
-    async def _async_auto_sleep_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _auto_sleep_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a sleep change event."""
         if event != "SLP":
             return
@@ -279,18 +283,14 @@ class DenonAVRDeviceInfo:
         else:
             self._sleep = int(parameter)
 
-    async def _async_room_size_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _room_size_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a room size change event."""
         if parameter[:3] != "RSZ":
             return
 
         self._room_size = parameter[4:]
 
-    async def _async_trigger_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _trigger_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a trigger change event."""
         if event != "TR":
             return
@@ -304,35 +304,29 @@ class DenonAVRDeviceInfo:
 
         self._triggers[int(values[0])] = values[1]
 
-    async def _async_delay_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _delay_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a delay change event."""
-        if event == "PS" and parameter[0:3] == "DEL":
-            self._delay = int(parameter[4:])
+        if event == "PS" and parameter[0:5] == "DELAY":
+            self._delay = int(parameter[6:])
 
-    async def _async_eco_mode_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _eco_mode_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an Eco-mode change event."""
         if event == "ECO" and parameter in ECO_MODE_MAP_LABELS:
             self._eco_mode = ECO_MODE_MAP_LABELS[parameter]
 
-    async def _async_hdmi_output_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _hdmi_output_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a HDMI output change event."""
         if event == "VS" and parameter[0:4] == "MONI":
             self._hdmi_output = HDMI_OUTPUT_MAP_LABELS[parameter]
 
-    async def _async_hdmi_audio_decode_callback(
+    def _hdmi_audio_decode_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a HDMI Audio Decode mode change event."""
         if event == "VS" and parameter[0:5] == "AUDIO":
             self._hdmi_audio_decode = parameter[6:]
 
-    async def _async_video_processing_mode_callback(
+    def _video_processing_mode_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a Video Processing Mode change event."""
@@ -341,7 +335,7 @@ class DenonAVRDeviceInfo:
                 parameter[3:]
             ]
 
-    async def _async_tactile_transducer_callback(
+    def _tactile_transducer_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a tactile transducer change event."""
@@ -361,9 +355,7 @@ class DenonAVRDeviceInfo:
         elif key == "TTRLPF":
             self._tactile_transducer_lpf = f"{int(value)} Hz"
 
-    async def _async_speaker_preset_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _speaker_preset_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a speaker preset change event."""
         if event != "SP":
             return
@@ -371,7 +363,7 @@ class DenonAVRDeviceInfo:
         if parameter[0:2] == "PR":
             self._speaker_preset = int(parameter[3:])
 
-    async def _async_bt_callback(self, zone: str, event: str, parameter: str) -> None:
+    def _bt_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Bluetooth change event."""
         if event != "BT" or parameter[0:2] != "TX":
             return
@@ -381,42 +373,56 @@ class DenonAVRDeviceInfo:
         else:
             self._bt_output_mode = BLUETOOTH_OUTPUT_MAP_LABELS[parameter[3:]]
 
-    async def _async_delay_time_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _delay_time_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a delay time change event."""
-        if event != "PS" or parameter[0:3] != "DEL":
+        # do not match "DELAY" as it's another event
+        if event != "PS" or parameter[0:3] != "DEL" or parameter[0:5] == "DELAY":
             return
 
         self._delay_time = int(parameter[4:])
 
-    async def _async_audio_restorer_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _audio_restorer_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an audio restorer change event."""
         if event != "PS" or parameter[0:4] != "RSTR":
             return
 
         self._audio_restorer = AUDIO_RESTORER_MAP_LABELS[parameter[5:]]
 
-    async def _async_graphic_eq_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _graphic_eq_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Graphic EQ change event."""
         if parameter[0:3] != "GEQ":
             return
 
         self._graphic_eq = parameter[4:]
 
-    async def _async_headphone_eq_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _headphone_eq_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Headphone EQ change event."""
         if parameter[0:3] != "HEQ":
             return
 
         self._headphone_eq = parameter[4:]
 
+    def _illumination_callback(self, zone: str, event: str, parameter: str) -> None:
+        """Handle an illumination change event."""
+        if event != "ILB" or parameter[0:3] != "ILL":
+            return
+
+        self._illumination = ILLUMINATION_MAP_LABELS[parameter[4:]]
+
+    def _auto_lip_sync_callback(self, zone: str, event: str, parameter: str) -> None:
+        """Handle a auto lip sync change event."""
+        if event != "PS" or parameter[0:3] != "HOS":
+            return
+
+        if parameter[6:] == "HOSALS":
+            auto_lip_sync = parameter[5:]
+        elif parameter[3:] == "HOS":
+            auto_lip_sync = parameter[4:]
+        else:
+            return
+
+        self._auto_lip_sync = auto_lip_sync
+
     def get_own_zone(self) -> str:
         """
         Get zone from actual instance.
@@ -454,32 +460,32 @@ class DenonAVRDeviceInfo:
                 power_event = "Z2"
             elif self.zone == ZONE3:
                 power_event = "Z3"
-            self.telnet_api.register_callback(power_event, self._async_power_callback)
-
-            self.telnet_api.register_callback("MN", self._async_settings_menu_callback)
-            self.telnet_api.register_callback("DIM", self._async_dimmer_callback)
-            self.telnet_api.register_callback("PS", self._async_delay_callback)
-            self.telnet_api.register_callback("ECO", self._async_eco_mode_callback)
-            self.telnet_api.register_callback("VS", self._async_hdmi_output_callback)
-            self.telnet_api.register_callback(
-                "VS", self._async_hdmi_audio_decode_callback
-            )
-            self.telnet_api.register_callback(
-                "VS", self._async_video_processing_mode_callback
-            )
+            self.telnet_api.register_callback(power_event, self._power_callback)
+
+            self.telnet_api.register_callback("MN", self._settings_menu_callback)
+            self.telnet_api.register_callback("DIM", self._dimmer_callback)
+            self.telnet_api.register_callback("PS", self._delay_callback)
+            self.telnet_api.register_callback("ECO", self._eco_mode_callback)
+            self.telnet_api.register_callback("VS", self._hdmi_output_callback)
+            self.telnet_api.register_callback("VS", self._hdmi_audio_decode_callback)
             self.telnet_api.register_callback(
-                "SS", self._async_tactile_transducer_callback
-            )
-            self.telnet_api.register_callback("STBY", self._async_auto_standby_callback)
-            self.telnet_api.register_callback("SLP", self._async_auto_sleep_callback)
-            self.telnet_api.register_callback("PS", self._async_room_size_callback)
-            self.telnet_api.register_callback("TR", self._async_trigger_callback)
-            self.telnet_api.register_callback("SP", self._async_speaker_preset_callback)
-            self.telnet_api.register_callback("BT", self._async_bt_callback)
-            self.telnet_api.register_callback("PS", self._async_delay_time_callback)
-            self.telnet_api.register_callback("PS", self._async_audio_restorer_callback)
-            self.telnet_api.register_callback("PS", self._async_graphic_eq_callback)
-            self.telnet_api.register_callback("PS", self._async_headphone_eq_callback)
+                "VS", self._video_processing_mode_callback
+            )
+            self.telnet_api.register_callback("SS", self._tactile_transducer_callback)
+            self.telnet_api.register_callback("STBY", self._auto_standby_callback)
+            self.telnet_api.register_callback("SLP", self._auto_sleep_callback)
+            self.telnet_api.register_callback("PS", self._room_size_callback)
+            self.telnet_api.register_callback("TR", self._trigger_callback)
+            self.telnet_api.register_callback("SP", self._speaker_preset_callback)
+            self.telnet_api.register_callback("BT", self._bt_callback)
+            self.telnet_api.register_callback("PS", self._delay_time_callback)
+            self.telnet_api.register_callback("PS", self._audio_restorer_callback)
+            self.telnet_api.register_callback("PS", self._graphic_eq_callback)
+            self.telnet_api.register_callback("PS", self._headphone_eq_callback)
+
+            if not self.is_denon:
+                self.telnet_api.register_callback("ILB", self._illumination_callback)
+                self.telnet_api.register_callback("SS", self._auto_lip_sync_callback)
 
             self._is_setup = True
             _LOGGER.debug("Finished device setup")
@@ -724,6 +730,7 @@ class DenonAVRDeviceInfo:
 
         if device_info is None:
             self.manufacturer = "Denon"
+            self.telnet_api.is_denon = self.is_denon
             self.model_name = "Unknown"
             self.serial_number = None
             _LOGGER.warning(
@@ -739,6 +746,7 @@ class DenonAVRDeviceInfo:
         if self.friendly_name is None and "friendlyName" in device_info:
             self.friendly_name = device_info["friendlyName"]
         self.manufacturer = device_info["manufacturer"]
+        self.telnet_api.is_denon = self.is_denon
         self.model_name = device_info["modelName"]
         self.serial_number = device_info["serialNumber"]
 
@@ -1046,11 +1054,36 @@ class DenonAVRDeviceInfo:
         """
         return self._headphone_eq
 
+    @property
+    def illumination(self) -> Optional[str]:
+        """
+        Return the illumination status for the device.
+
+        Only available on Marantz devices and when using Telnet.
+
+        Possible values are: "Auto", "Bright", "Dim", "Dark", "Off"
+        """
+        return self._illumination
+
+    @property
+    def auto_lip_sync(self) -> Optional[bool]:
+        """
+        Return the auto lip sync status for the device.
+
+        Only available on Marantz devices and when using Telnet.
+        """
+        return self._auto_lip_sync
+
     @property
     def telnet_available(self) -> bool:
         """Return true if telnet is connected and healthy."""
         return self.telnet_api.connected and self.telnet_api.healthy
 
+    @property
+    def is_denon(self) -> bool:
+        """Return true if the receiver is a Denon device."""
+        return "denon" in self.manufacturer.lower()
+
     ##########
     # Getter #
     ##########
@@ -1199,7 +1232,7 @@ class DenonAVRDeviceInfo:
 
     async def async_dimmer(self, mode: DimmerModes) -> None:
         """Set dimmer mode on receiver via HTTP get command."""
-        if mode not in DimmerModes:
+        if mode not in self._dimmer_modes:
             raise AvrCommandError("Invalid dimmer mode")
 
         mapped_mode = DIMMER_MODE_MAP[mode]
@@ -1397,15 +1430,19 @@ class DenonAVRDeviceInfo:
             raise AvrCommandError("Quick select number must be between 1 and 5")
 
         if self.telnet_available:
+            if self.is_denon:
+                command = self.telnet_commands.command_quick_select_mode
+            else:
+                command = self.telnet_commands.command_smart_select_mode
             await self.telnet_api.async_send_commands(
-                self.telnet_commands.command_quick_select_mode.format(
-                    number=quick_select_number
-                )
+                command.format(number=quick_select_number)
             )
         else:
-            await self.api.async_get_command(
-                self.urls.command_quick_select_mode.format(number=quick_select_number)
-            )
+            if self.is_denon:
+                command = self.urls.command_quick_select_mode
+            else:
+                command = self.urls.command_smart_select_mode
+            await self.api.async_get_command(command.format(number=quick_select_number))
 
     async def async_quick_select_memory(self, quick_select_number: int) -> None:
         """
@@ -1417,15 +1454,19 @@ class DenonAVRDeviceInfo:
             raise AvrCommandError("Quick select number must be between 1 and 5")
 
         if self.telnet_available:
+            if self.is_denon:
+                command = self.telnet_commands.command_quick_select_memory
+            else:
+                command = self.telnet_commands.command_smart_select_memory
             await self.telnet_api.async_send_commands(
-                self.telnet_commands.command_quick_select_memory.format(
-                    number=quick_select_number
-                )
+                command.format(number=quick_select_number)
             )
         else:
-            await self.api.async_get_command(
-                self.urls.command_quick_select_memory.format(number=quick_select_number)
-            )
+            if self.is_denon:
+                command = self.urls.command_quick_select_memory
+            else:
+                command = self.urls.command_smart_select_memory
+            await self.api.async_get_command(command.format(number=quick_select_number))
 
     async def async_delay_up(self) -> None:
         """Delay up on receiver via HTTP get command."""
@@ -1447,7 +1488,7 @@ class DenonAVRDeviceInfo:
 
     async def async_eco_mode(self, mode: EcoModes) -> None:
         """Set Eco mode."""
-        if mode not in EcoModes:
+        if mode not in self._eco_modes:
             raise AvrCommandError("Invalid Eco mode")
 
         mapped_mode = ECO_MODE_MAP[mode]
@@ -1462,10 +1503,10 @@ class DenonAVRDeviceInfo:
 
     async def async_hdmi_output(self, output: HDMIOutputs) -> None:
         """Set HDMI output."""
-        if output not in HDMIOutputs:
+        if output not in self._hdmi_outputs:
             raise AvrCommandError("Invalid HDMI output mode")
 
-        mapped_output = HDMIOutputs[output]
+        mapped_output = HDMI_OUTPUT_MAP[output]
         if self.telnet_available:
             await self.telnet_api.async_send_commands(
                 self.telnet_commands.command_hdmi_output.format(output=mapped_output)
@@ -1505,11 +1546,17 @@ class DenonAVRDeviceInfo:
                 self.urls.command_video_processing_mode.format(mode=processing_mode)
             )
 
-    async def async_status(self) -> str:
+    async def async_status(self) -> None:
         """Get status of receiver via HTTP get command."""
-        if "denon" not in self.manufacturer.lower():
+        if not self.is_denon:
             raise AvrCommandError("Status command is only supported for Denon devices")
-        return await self.api.async_get_command(self.urls.command_status)
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_status
+            )
+        else:
+            await self.api.async_get_command(self.urls.command_status)
 
     async def async_system_reset(self) -> None:
         """DANGER! Reset the receiver via HTTP get command."""
@@ -1799,6 +1846,108 @@ class DenonAVRDeviceInfo:
         else:
             await self.async_headphone_eq_on()
 
+    async def async_hdmi_cec_on(self) -> None:
+        """Turn on HDMI CEC on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_denon_hdmi_cec_on
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_on
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_denon_hdmi_cec_on
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_on
+            )
+
+    async def async_hdmi_cec_off(self) -> None:
+        """Turn off HDMI CEC on receiver via HTTP get command."""
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_denon_hdmi_cec_off
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_off
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_denon_hdmi_cec_off
+                if self.is_denon
+                else self.urls.command_marantz_hdmi_cec_off
+            )
+
+    async def async_illumination(self, mode: Illuminations):
+        """
+        Set illumination mode on receiver via HTTP get command.
+
+        Only available on Marantz devices.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Illumination is only available for Marantz devices")
+
+        if mode not in self._illuminations:
+            raise AvrCommandError("Invalid illumination mode")
+
+        mapped_mode = ILLUMINATION_MAP[mode]
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_illumination.format(mode=mapped_mode)
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_illumination.format(mode=mapped_mode)
+            )
+
+    async def async_auto_lip_sync_on(self) -> None:
+        """
+        Turn on auto lip sync on receiver via HTTP get command.
+
+        Only available on Marantz devices.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Auto lip sync is only available for Marantz devices")
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_auto_lip_sync.format(mode="ON")
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_auto_lip_sync.format(mode="ON")
+            )
+
+    async def async_auto_lip_sync_off(self) -> None:
+        """
+        Turn off auto lip sync on receiver via HTTP get command.
+
+        Only available on Marantz devices.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Auto lip sync is only available for Marantz devices")
+
+        if self.telnet_available:
+            await self.telnet_api.async_send_commands(
+                self.telnet_commands.command_auto_lip_sync.format(mode="OFF")
+            )
+        else:
+            await self.api.async_get_command(
+                self.urls.command_auto_lip_sync.format(mode="OFF")
+            )
+
+    async def async_auto_lip_sync_toggle(self) -> None:
+        """
+        Toggle auto lip sync on receiver via HTTP get command.
+
+        Only available on Marantz devices and when using Telnet.
+        """
+        if self.is_denon:
+            raise AvrCommandError("Auto lip sync is only available for Marantz devices")
+
+        if self._auto_lip_sync:
+            await self.async_auto_lip_sync_off()
+        else:
+            await self.async_auto_lip_sync_on()
+
 
 @attr.s(auto_attribs=True, on_setattr=DENON_ATTR_SETATTR)
 class DenonAVRFoundation: