denonavr 1.1.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

denonavr/soundmode.py

@@ -19,22 +19,28 @@ from .appcommand import AppCommands
 from .const import (
     ALL_ZONE_STEREO,
     AURO_3D_MODE_MAP,
-    AURO_3D_MODE_MAP_MAP_LABELS,
+    AURO_3D_MODE_MAP_REVERSE,
     AURO_MATIC_3D_PRESET_MAP,
-    AURO_MATIC_3D_PRESET_MAP_LABELS,
+    AURO_MATIC_3D_PRESET_MAP_REVERSE,
+    DAC_FILTERS_MAP,
+    DAC_FILTERS_MAP_REVERSE,
     DENON_ATTR_SETATTR,
     DIALOG_ENHANCER_LEVEL_MAP,
-    DIALOG_ENHANCER_LEVEL_MAP_LABELS,
+    DIALOG_ENHANCER_LEVEL_MAP_REVERSE,
     EFFECT_SPEAKER_SELECTION_MAP,
-    EFFECT_SPEAKER_SELECTION_MAP_LABELS,
+    EFFECT_SPEAKER_SELECTION_MAP_REVERSE,
+    MDAX_MAP,
+    MDAX_MAP_REVERSE,
     SOUND_MODE_MAPPING,
     Auro3DModes,
     AuroMatic3DPresets,
+    DACFilters,
     DialogEnhancerLevels,
     DRCs,
     EffectSpeakers,
     IMAXHPFs,
     IMAXLPFs,
+    MDAXs,
 )
 from .exceptions import AvrCommandError, AvrIncompleteResponseError, AvrProcessingError
 from .foundation import DenonAVRFoundation, convert_on_off_bool
@@ -119,18 +125,18 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         converter=attr.converters.optional(convert_on_off_bool), default=None
     )
     _dialog_enhancer_level: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(DIALOG_ENHANCER_LEVEL_MAP.get), default=None
     )
     _dialog_enhancer_levels = get_args(DialogEnhancerLevels)
     _auromatic_3d_preset: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(AURO_MATIC_3D_PRESET_MAP.get), default=None
     )
     _auromatic_3d_presets = get_args(AuroMatic3DPresets)
     _auromatic_3d_strength: Optional[int] = attr.ib(
         converter=attr.converters.optional(int), default=None
     )
     _auro_3d_mode: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(AURO_3D_MODE_MAP.get), default=None
     )
     _auro_3d_modes = get_args(Auro3DModes)
     _dialog_control: Optional[int] = attr.ib(
@@ -140,11 +146,20 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         converter=attr.converters.optional(convert_on_off_bool), default=None
     )
     _effect_speaker_selection: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(EFFECT_SPEAKER_SELECTION_MAP.get),
+        default=None,
     )
     _effect_speakers = get_args(EffectSpeakers)
     _drc: Optional[str] = attr.ib(converter=attr.converters.optional(str), default=None)
     _drcs = get_args(DRCs)
+    _mdax: Optional[str] = attr.ib(
+        converter=attr.converters.optional(MDAX_MAP.get), default=None
+    )
+    _mdaxs = get_args(MDAXs)
+    _dac_filter: Optional[str] = attr.ib(
+        converter=attr.converters.optional(DAC_FILTERS_MAP.get), default=None
+    )
+    _dac_filters = get_args(DACFilters)
     _sound_mode_map: Dict[str, list] = attr.ib(
         validator=attr.validators.deep_mapping(
             attr.validators.instance_of(str),
@@ -188,43 +203,41 @@ class DenonAVRSoundMode(DenonAVRFoundation):
                 for tag in self.appcommand_attrs:
                     self._device.api.add_appcommand_update_tag(tag)
 
+            self._device.telnet_api.register_callback("MS", self._soundmode_callback)
+            self._device.telnet_api.register_callback("PS", self._neural_x_callback)
+            self._device.telnet_api.register_callback("PS", self._imax_callback)
+            self._device.telnet_api.register_callback("PS", self._cinema_eq_callback)
             self._device.telnet_api.register_callback(
-                "MS", self._async_soundmode_callback
-            )
-            self._device.telnet_api.register_callback(
-                "PS", self._async_neural_x_callback
-            )
-            self._device.telnet_api.register_callback("PS", self._async_imax_callback)
-            self._device.telnet_api.register_callback(
-                "PS", self._async_cinema_eq_callback
+                "PS", self._center_spread_callback
             )
             self._device.telnet_api.register_callback(
-                "PS", self._async_center_spread_callback
+                "PS", self._loudness_management_callback
             )
             self._device.telnet_api.register_callback(
-                "PS", self._async_loudness_management_callback
+                "PS", self._dialog_enhancer_callback
             )
+            self._device.telnet_api.register_callback("PS", self._auro_callback)
             self._device.telnet_api.register_callback(
-                "PS", self._async_dialog_enhancer_callback
+                "PS", self._dialog_control_callback
             )
-            self._device.telnet_api.register_callback("PS", self._async_auro_callback)
             self._device.telnet_api.register_callback(
-                "PS", self._async_dialog_control_callback
+                "PS", self._speaker_virtualizer_callback
             )
             self._device.telnet_api.register_callback(
-                "PS", self._async_speaker_virtualizer_callback
+                "PS", self._effect_speaker_selection_callback
             )
-            self._device.telnet_api.register_callback(
-                "PS", self._async_effect_speaker_selection_callback
-            )
-            self._device.telnet_api.register_callback("PS", self._async_drc_callback)
+            self._device.telnet_api.register_callback("PS", self._drc_callback)
+
+            if not self._device.is_denon:
+                self._device.telnet_api.register_callback("PS", self._mdax_callback)
+                self._device.telnet_api.register_callback(
+                    "PS", self._dac_filter_callback
+                )
 
             self._is_setup = True
             _LOGGER.debug("Finished sound mode setup")
 
-    async def _async_soundmode_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _soundmode_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a sound mode change event."""
         if self._device.zone != zone:
             return
@@ -235,15 +248,13 @@ class DenonAVRSoundMode(DenonAVRFoundation):
 
         self._sound_mode_raw = parameter
 
-    async def _async_neural_x_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _neural_x_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Neural X:change event."""
         parameter_name_length = len("NEURAL")
         if parameter[:parameter_name_length] == "NEURAL":
             self._neural_x = parameter[parameter_name_length + 1 :]
 
-    async def _async_imax_callback(self, zone: str, event: str, parameter: str) -> None:
+    def _imax_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an IMAX change event."""
         key_value = parameter.split()
         if len(key_value) != 2 or key_value[0][:4] != "IMAX":
@@ -254,68 +265,58 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         elif key_value[0] == "IMAXAUD":
             self._imax_audio_settings = parameter[8:]
         elif key_value[0] == "IMAXHPF":
-            self._imax_hpf = int(parameter[8:])
+            self._imax_hpf = parameter[8:]
         elif key_value[0] == "IMAXLPF":
-            self._imax_lpf = int(parameter[8:])
+            self._imax_lpf = parameter[8:]
         elif key_value[0] == "IMAXSWM":
             self._imax_subwoofer_mode = parameter[8:]
         elif key_value[0] == "IMAXSWO":
             self._imax_subwoofer_output = parameter[8:]
 
-    async def _async_cinema_eq_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _cinema_eq_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Cinema EQ change event."""
         if parameter[:10] == "CINEMA EQ.":
             self._cinema_eq = parameter[10:]
 
-    async def _async_center_spread_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _center_spread_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Center Spread change event."""
         if parameter[:3] == "CES":
             self._center_spread = parameter[4:]
 
-    async def _async_loudness_management_callback(
+    def _loudness_management_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a Loudness Management change event."""
         if parameter[:3] == "LOM":
             self._loudness_management = parameter[4:]
 
-    async def _async_dialog_enhancer_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _dialog_enhancer_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Dialog Enhancer change event."""
         if parameter[:3] == "DEH":
-            self._dialog_enhancer_level = DIALOG_ENHANCER_LEVEL_MAP_LABELS[
-                parameter[4:]
-            ]
+            self._dialog_enhancer_level = parameter[4:]
 
-    async def _async_auro_callback(self, zone: str, event: str, parameter: str) -> None:
+    def _auro_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Auro change event."""
         key_value = parameter.split()
         if len(key_value) != 2 or key_value[0][:4] != "AURO":
             return
 
         if key_value[0] == "AUROPR":
-            self._auromatic_3d_preset = AURO_MATIC_3D_PRESET_MAP_LABELS[parameter[7:]]
+            self._auromatic_3d_preset = parameter[7:]
         elif key_value[0] == "AUROST":
-            self._auromatic_3d_strength = int(parameter[7:])
+            self._auromatic_3d_strength = parameter[7:]
         elif key_value[0] == "AUROMODE":
-            self._auro_3d_mode = AURO_3D_MODE_MAP_MAP_LABELS[parameter[9:]]
+            self._auro_3d_mode = parameter[9:]
 
-    async def _async_dialog_control_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _dialog_control_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Dialog Control change event."""
         key_value = parameter.split()
         if len(key_value) != 2 or key_value[0] != "DIC":
             return
 
-        self._dialog_control = int(key_value[1])
+        self._dialog_control = key_value[1]
 
-    async def _async_speaker_virtualizer_callback(
+    def _speaker_virtualizer_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a Speaker Virtualizer change event."""
@@ -325,7 +326,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
 
         self._speaker_virtualizer = key_value[1]
 
-    async def _async_effect_speaker_selection_callback(
+    def _effect_speaker_selection_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle a Effect Speaker Selection change event."""
@@ -333,11 +334,9 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if len(key_value) != 2 or key_value[0] != "SP":
             return
 
-        self._effect_speaker_selection = EFFECT_SPEAKER_SELECTION_MAP_LABELS[
-            key_value[1]
-        ]
+        self._effect_speaker_selection = key_value[1]
 
-    async def _async_drc_callback(self, zone: str, event: str, parameter: str) -> None:
+    def _drc_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a DRC change event."""
         key_value = parameter.split()
         if len(key_value) != 2 or key_value[0] != "DRC":
@@ -345,6 +344,22 @@ class DenonAVRSoundMode(DenonAVRFoundation):
 
         self._drc = key_value[1]
 
+    def _mdax_callback(self, zone: str, event: str, parameter: str) -> None:
+        """Handle a M-DAX change event."""
+        key_value = parameter.split()
+        if len(key_value) != 2 or key_value[0] != "MDAX":
+            return
+
+        self._mdax = key_value[1]
+
+    def _dac_filter_callback(self, zone: str, event: str, parameter: str) -> None:
+        """Handle a DAC Filter change event."""
+        key_value = parameter.split()
+        if len(key_value) != 2 or key_value[0] != "DACFIL":
+            return
+
+        self._dac_filter = key_value[1]
+
     async def async_update(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
@@ -691,6 +706,28 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         """
         return self._drc
 
+    @property
+    def mdax(self) -> Optional[str]:
+        """
+        Return the current M-DAX status.
+
+        Only available on Marantz devices and when using Telnet.
+
+        Possible values are: "Off", "Low", "Medium", "High"
+        """
+        return self._mdax
+
+    @property
+    def dac_filter(self) -> Optional[str]:
+        """
+        Return the current DAC Filter status.
+
+        Only available on Marantz devices and when using Telnet.
+
+        Possible values are: "Mode 1", "Mode 2"
+        """
+        return self._dac_filter
+
     ##########
     # Setter #
     ##########
@@ -1017,7 +1054,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if level not in self._dialog_enhancer_levels:
             raise AvrCommandError(f"{level} is not a valid dialog enhancer level")
 
-        level_mapped = DIALOG_ENHANCER_LEVEL_MAP[level]
+        level_mapped = DIALOG_ENHANCER_LEVEL_MAP_REVERSE[level]
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_dialog_enhancer.format(
@@ -1034,7 +1071,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if preset not in self._auromatic_3d_presets:
             raise AvrCommandError(f"{preset} is not a valid Auro-Matic 3D Preset")
 
-        local_preset = AURO_MATIC_3D_PRESET_MAP[preset]
+        local_preset = AURO_MATIC_3D_PRESET_MAP_REVERSE[preset]
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_auromatic_3d_preset.format(
@@ -1102,7 +1139,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if mode not in self._auro_3d_modes:
             raise AvrCommandError(f"{mode} is not a valid Auro 3D Mode")
 
-        local_mode = AURO_3D_MODE_MAP[mode]
+        local_mode = AURO_3D_MODE_MAP_REVERSE[mode]
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_auro_3d_mode.format(
@@ -1199,7 +1236,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if mode not in self._effect_speakers:
             raise AvrCommandError(f"{mode} is not a valid effect speaker selection")
 
-        local_mode = EFFECT_SPEAKER_SELECTION_MAP[mode]
+        local_mode = EFFECT_SPEAKER_SELECTION_MAP_REVERSE[mode]
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_effect_speaker_selection.format(
@@ -1227,6 +1264,67 @@ class DenonAVRSoundMode(DenonAVRFoundation):
                 self._device.urls.command_drc.format(mode=mode)
             )
 
+    async def async_mdax(self, mode: MDAXs) -> None:
+        """
+        Set M-DAX mode.
+
+        Only available for Marantz devices.
+        """
+        if self._device.is_denon:
+            raise AvrCommandError("M-DAX is only available for Marantz devices")
+
+        if mode not in self._mdaxs:
+            raise AvrCommandError(f"{mode} is not a valid M-DAX mode")
+
+        local_mode = MDAX_MAP_REVERSE[mode]
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_mdax.format(mode=local_mode)
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_mdax.format(mode=local_mode)
+            )
+
+    async def async_dac_filter(self, mode: DACFilters) -> None:
+        """
+        Set DAC Filter mode.
+
+        Only available for Marantz devices.
+        """
+        if self._device.is_denon:
+            raise AvrCommandError("DAC Filter is only available for Marantz devices")
+
+        if mode not in self._dac_filters:
+            raise AvrCommandError(f"{mode} is not a valid DAC Filter mode")
+
+        local_mode = DAC_FILTERS_MAP_REVERSE[mode]
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_dac_filter.format(mode=local_mode)
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_dac_filter.format(mode=local_mode)
+            )
+
+    async def async_dolby_atmos_toggle(self):
+        """Toggle Dolby Atmos sound mode."""
+        if self._device.telnet_available:
+            command = (
+                self._device.telnet_commands.command_dolby_atmos_toggle_denon
+                if self._device.is_denon
+                else self._device.telnet_commands.command_dolby_atmos_toggle_marantz
+            )
+            await self._device.telnet_api.async_send_commands(command)
+        else:
+            command = (
+                self._device.urls.command_dolby_atmos_toggle_denon
+                if self._device.is_denon
+                else self._device.urls.command_dolby_atmos_toggle_marantz
+            )
+            await self._device.api.async_get_command(command)
+
 
 def sound_mode_factory(instance: DenonAVRFoundation) -> DenonAVRSoundMode:
     """Create DenonAVRSoundMode at receiver instances."""

denonavr/ssdp.py

@@ -91,17 +91,18 @@ async def async_identify_denonavr_receivers() -> List[Dict]:
     # Check which responding device is a DenonAVR device and prepare output
     receivers = []
 
-    for url in urls:
-        try:
-            async with httpx.AsyncClient() as client:
-                res = await client.get(url, timeout=5.0)
-                res.raise_for_status()
-        except httpx.HTTPError:
-            continue
-        else:
-            receiver = evaluate_scpd_xml(url, res.text)
-            if receiver is not None:
-                receivers.append(receiver)
+    async with httpx.AsyncClient() as client:
+        for url in urls:
+            try:
+                async with client.stream("GET", url, timeout=5.0) as res:
+                    res.raise_for_status()
+                    await res.aread()
+            except httpx.HTTPError:
+                continue
+            else:
+                receiver = evaluate_scpd_xml(url, res.text)
+                if receiver is not None:
+                    receivers.append(receiver)
 
     return receivers
 

denonavr/tonecontrol.py

@@ -67,16 +67,12 @@ class DenonAVRToneControl(DenonAVRFoundation):
                 for tag in self.appcommand_attrs:
                     self._device.api.add_appcommand_update_tag(tag)
 
-            self._device.telnet_api.register_callback(
-                "PS", self._async_sound_detail_callback
-            )
+            self._device.telnet_api.register_callback("PS", self._sound_detail_callback)
 
             self._is_setup = True
             _LOGGER.debug("Finished tone control setup")
 
-    async def _async_sound_detail_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _sound_detail_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a sound detail change event."""
         if self._device.zone != zone:
             return