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

denonavr/input.py

@@ -164,7 +164,7 @@ class DenonAVRInput(DenonAVRFoundation):
     _image_url: Optional[str] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
-    _image_available: Optional[str] = attr.ib(
+    _image_available: Optional[bool] = attr.ib(
         converter=attr.converters.optional(str), default=None
     )
 
@@ -174,6 +174,7 @@ class DenonAVRInput(DenonAVRFoundation):
         ),
         default=attr.Factory(set),
     )
+    _callback_tasks: Set[asyncio.Task] = attr.ib(attr.Factory(set))
 
     # Update tags for attributes
     # AppCommand.xml interface
@@ -197,22 +198,18 @@ class DenonAVRInput(DenonAVRFoundation):
             power_event = "Z2"
         elif self._device.zone == ZONE3:
             power_event = "Z3"
+        self._device.telnet_api.register_callback(power_event, self._power_callback)
+        self._device.telnet_api.register_callback("SI", self._input_callback)
+        self._device.telnet_api.register_callback("NSE", self._netaudio_callback)
+        self._device.telnet_api.register_callback("TF", self._tuner_callback)
+        self._device.telnet_api.register_callback("HD", self._hdtuner_callback)
         self._device.telnet_api.register_callback(
-            power_event, self._async_power_callback
-        )
-        self._device.telnet_api.register_callback("SI", self._async_input_callback)
-        self._device.telnet_api.register_callback("NSE", self._async_netaudio_callback)
-        self._device.telnet_api.register_callback("TF", self._async_tuner_callback)
-        self._device.telnet_api.register_callback("HD", self._async_hdtuner_callback)
-        self._device.telnet_api.register_callback(
-            "SS", self._async_input_func_update_callback
+            "SS", self._input_func_update_callback
         )
 
         self._is_setup = True
 
-    async def _async_input_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _input_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an input change event."""
         if self._device.zone != zone:
             return
@@ -228,9 +225,7 @@ class DenonAVRInput(DenonAVRFoundation):
             self._unset_media_state()
             self._state = STATE_ON
 
-    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._device.zone != zone:
             return
@@ -285,9 +280,7 @@ class DenonAVRInput(DenonAVRFoundation):
         else:
             self._stop_media_update()
 
-    async def _async_netaudio_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _netaudio_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a netaudio update event."""
         if self._device.power != POWER_ON:
             return
@@ -305,12 +298,13 @@ class DenonAVRInput(DenonAVRFoundation):
         self._station = None
 
         # Refresh cover with a hash for media URL when track is changing
-        self._image_url = ALBUM_COVERS_URL.format(
-            host=self._device.api.host,
-            port=self._device.api.port,
-            hash=hash((self._title, self._artist, self._album)),
+        self._set_image_url(
+            ALBUM_COVERS_URL.format(
+                host=self._device.api.host,
+                port=self._device.api.port,
+                hash=hash((self._title, self._artist, self._album)),
+            )
         )
-        await self._async_test_image_accessible()
 
     def _schedule_tuner_update(self) -> None:
         """Schedule a tuner update task."""
@@ -330,9 +324,7 @@ class DenonAVRInput(DenonAVRFoundation):
         else:
             self._stop_media_update()
 
-    async def _async_tuner_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _tuner_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a tuner update event."""
         if self._device.power != POWER_ON:
             return
@@ -353,10 +345,11 @@ class DenonAVRInput(DenonAVRFoundation):
         self._album = None
 
         # No special cover, using a static one
-        self._image_url = STATIC_ALBUM_URL.format(
-            host=self._device.api.host, port=self._device.api.port
+        self._set_image_url(
+            STATIC_ALBUM_URL.format(
+                host=self._device.api.host, port=self._device.api.port
+            )
         )
-        await self._async_test_image_accessible()
 
     def _schedule_hdtuner_update(self) -> None:
         """Schedule a HD tuner update task."""
@@ -374,9 +367,7 @@ class DenonAVRInput(DenonAVRFoundation):
         else:
             self._stop_media_update()
 
-    async def _async_hdtuner_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _hdtuner_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle an HD tuner update event."""
         if self._device.power != POWER_ON:
             return
@@ -396,19 +387,35 @@ class DenonAVRInput(DenonAVRFoundation):
         self._frequency = None
 
         # No special cover, using a static one
-        self._image_url = STATIC_ALBUM_URL.format(
-            host=self._device.api.host, port=self._device.api.port
+        self._set_image_url(
+            STATIC_ALBUM_URL.format(
+                host=self._device.api.host, port=self._device.api.port
+            )
         )
-        await self._async_test_image_accessible()
 
-    async def _async_input_func_update_callback(
+    def _input_func_update_callback(
         self, zone: str, event: str, parameter: str
     ) -> None:
         """Handle input func update events."""
         if self._input_func_update_lock.locked():
             return
-        async with self._input_func_update_lock:
-            await self.async_update_inputfuncs()
+        task = asyncio.create_task(self.async_update_inputfuncs())
+        self._callback_tasks.add(task)
+        task.add_done_callback(self._callback_tasks.discard)
+
+    def _set_image_url(self, image_url: str) -> None:
+        """Set image URL if it is accessible."""
+        if self._image_available is False:
+            return
+
+        self._image_url = image_url
+
+        if self._image_available:
+            return
+
+        task = asyncio.create_task(self._async_test_image_accessible())
+        self._callback_tasks.add(task)
+        task.add_done_callback(self._callback_tasks.discard)
 
     async def async_update(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
@@ -621,16 +628,17 @@ class DenonAVRInput(DenonAVRFoundation):
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
         """Update sources list from receiver."""
-        if self._device.receiver in [AVR_X, AVR_X_2016]:
-            await self._async_update_inputfuncs_avr_x(
-                global_update=global_update, cache_id=cache_id
-            )
-        elif self._device.receiver in [AVR]:
-            await self._async_update_inputfuncs_avr(cache_id=cache_id)
-        else:
-            raise AvrProcessingError(
-                "Device is not setup correctly, receiver type not set"
-            )
+        async with self._input_func_update_lock:
+            if self._device.receiver in [AVR_X, AVR_X_2016]:
+                await self._async_update_inputfuncs_avr_x(
+                    global_update=global_update, cache_id=cache_id
+                )
+            elif self._device.receiver in [AVR]:
+                await self._async_update_inputfuncs_avr(cache_id=cache_id)
+            else:
+                raise AvrProcessingError(
+                    "Device is not setup correctly, receiver type not set"
+                )
 
     async def _async_update_inputfuncs_avr_x(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None

denonavr/soundmode.py

@@ -22,19 +22,25 @@ from .const import (
     AURO_3D_MODE_MAP_MAP_LABELS,
     AURO_MATIC_3D_PRESET_MAP,
     AURO_MATIC_3D_PRESET_MAP_LABELS,
+    DAC_FILTERS_MAP,
+    DAC_FILTERS_MAP_LABELS,
     DENON_ATTR_SETATTR,
     DIALOG_ENHANCER_LEVEL_MAP,
     DIALOG_ENHANCER_LEVEL_MAP_LABELS,
     EFFECT_SPEAKER_SELECTION_MAP,
     EFFECT_SPEAKER_SELECTION_MAP_LABELS,
+    MDAX_MAP,
+    MDAX_MAP_LABELS,
     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
@@ -145,6 +151,14 @@ class DenonAVRSoundMode(DenonAVRFoundation):
     _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(str), default=None
+    )
+    _mdaxs = get_args(MDAXs)
+    _dac_filter: Optional[str] = attr.ib(
+        converter=attr.converters.optional(str), 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 +202,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
-            )
-            self._device.telnet_api.register_callback(
-                "PS", self._async_center_spread_callback
+                "PS", self._center_spread_callback
             )
             self._device.telnet_api.register_callback(
-                "PS", self._async_loudness_management_callback
+                "PS", self._loudness_management_callback
             )
             self._device.telnet_api.register_callback(
-                "PS", self._async_dialog_enhancer_callback
+                "PS", self._dialog_enhancer_callback
             )
-            self._device.telnet_api.register_callback("PS", self._async_auro_callback)
+            self._device.telnet_api.register_callback("PS", self._auro_callback)
             self._device.telnet_api.register_callback(
-                "PS", self._async_dialog_control_callback
+                "PS", self._dialog_control_callback
             )
             self._device.telnet_api.register_callback(
-                "PS", self._async_speaker_virtualizer_callback
+                "PS", self._speaker_virtualizer_callback
             )
             self._device.telnet_api.register_callback(
-                "PS", self._async_effect_speaker_selection_callback
+                "PS", self._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 +247,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":
@@ -262,37 +272,31 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         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:]
             ]
 
-    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":
@@ -305,9 +309,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         elif key_value[0] == "AUROMODE":
             self._auro_3d_mode = AURO_3D_MODE_MAP_MAP_LABELS[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":
@@ -315,7 +317,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
 
         self._dialog_control = int(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 +327,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."""
@@ -337,7 +339,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
             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 +347,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 = MDAX_MAP_LABELS[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 = DAC_FILTERS_MAP_LABELS[key_value[1]]
+
     async def async_update(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
@@ -691,6 +709,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 #
     ##########
@@ -1227,6 +1267,50 @@ 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[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[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)
+            )
+
 
 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

denonavr/volume.py

@@ -82,25 +82,17 @@ class DenonAVRVolume(DenonAVRFoundation):
         for tag in self.appcommand_attrs:
             self._device.api.add_appcommand_update_tag(tag)
 
-        self._device.telnet_api.register_callback("MV", self._async_volume_callback)
-        self._device.telnet_api.register_callback("MU", self._async_mute_callback)
-        self._device.telnet_api.register_callback(
-            "CV", self._async_channel_volume_callback
-        )
-        self._device.telnet_api.register_callback(
-            "PS", self._async_subwoofer_state_callback
-        )
-        self._device.telnet_api.register_callback(
-            "PS", self._async_subwoofer_levels_callback
-        )
-        self._device.telnet_api.register_callback("PS", self._async_lfe_callback)
-        self._device.telnet_api.register_callback("PS", self._async_bass_sync_callback)
+        self._device.telnet_api.register_callback("MV", self._volume_callback)
+        self._device.telnet_api.register_callback("MU", self._mute_callback)
+        self._device.telnet_api.register_callback("CV", self._channel_volume_callback)
+        self._device.telnet_api.register_callback("PS", self._subwoofer_state_callback)
+        self._device.telnet_api.register_callback("PS", self._subwoofer_levels_callback)
+        self._device.telnet_api.register_callback("PS", self._lfe_callback)
+        self._device.telnet_api.register_callback("PS", self._bass_sync_callback)
 
         self._is_setup = True
 
-    async def _async_volume_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _volume_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a volume change event."""
         if self._device.zone != zone:
             return
@@ -112,16 +104,14 @@ class DenonAVRVolume(DenonAVRFoundation):
             fraction = 0.1 * float(parameter[2])
             self._volume = -80.0 + whole_number + fraction
 
-    async def _async_mute_callback(self, zone: str, event: str, parameter: str) -> None:
+    def _mute_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a muting change event."""
         if self._device.zone != zone:
             return
 
         self._muted = parameter
 
-    async def _async_channel_volume_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _channel_volume_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a channel volume change event."""
         if event != "CV":
             return
@@ -141,16 +131,12 @@ class DenonAVRVolume(DenonAVRFoundation):
         volume = channel_volume[1]
         self._channel_volumes[channel] = CHANNEL_VOLUME_MAP[volume]
 
-    async def _async_subwoofer_state_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _subwoofer_state_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a subwoofer state change event."""
         if parameter[:3] == "SWR":
             self._subwoofer = parameter[4:]
 
-    async def _async_subwoofer_levels_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _subwoofer_levels_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a subwoofer levels change event."""
         if parameter[:3] != "SWL":
             return
@@ -173,16 +159,14 @@ class DenonAVRVolume(DenonAVRFoundation):
         elif level in CHANNEL_VOLUME_MAP:
             self._subwoofer_levels[subwoofer] = CHANNEL_VOLUME_MAP[level]
 
-    async def _async_lfe_callback(self, zone: str, event: str, parameter: str) -> None:
+    def _lfe_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a LFE change event."""
         if parameter[:3] != "LFE":
             return
 
         self._lfe = int(parameter[4:]) * -1
 
-    async def _async_bass_sync_callback(
-        self, zone: str, event: str, parameter: str
-    ) -> None:
+    def _bass_sync_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a LFE change event."""
         if parameter[:3] != "BSC":
             return

{denonavr-1.1.2.dist-info → denonavr-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: denonavr
-Version: 1.1.2
+Version: 1.2.0
 Summary: Automation Library for Denon AVR receivers
 Author-email: Oliver Goetz <scarface@mywoh.de>
 License: MIT
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8
 License-File: LICENSE