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

denonavr/input.py

@@ -28,6 +28,7 @@ from .const import (
     DENON_ATTR_SETATTR,
     HDTUNER_SOURCES,
     MAIN_ZONE,
+    NETAUDIO_PLAYING,
     NETAUDIO_SOURCES,
     PLAYING_SOURCES,
     POWER_ON,
@@ -36,6 +37,7 @@ from .const import (
     STATE_ON,
     STATE_PAUSED,
     STATE_PLAYING,
+    STATE_STOPPED,
     STATIC_ALBUM_URL,
     TELNET_MAPPING,
     TUNER_SOURCES,
@@ -73,14 +75,16 @@ def set_input_func(
     if value is None:
         return value
     # Map from input_func_map
-    # AirPlay and Internet Radio are not always listed in available sources
-    if value in ["AirPlay", "Internet Radio"]:
-        if value not in instance._input_func_map:
-            instance._additional_input_funcs.add(value)
-            instance._input_func_map[value] = value
-            instance._input_func_map_rev[value] = value
-            instance._netaudio_func_list.append(value)
-            instance._playing_func_list.append(value)
+    # Some inputs are not always listed in available sources
+    if (
+        value in {"AirPlay", "Internet Radio", "Media Server", "NET"}
+        and value not in instance._input_func_map
+    ):
+        instance._additional_input_funcs.add(value)
+        instance._input_func_map[value] = value
+        instance._input_func_map_rev[value] = value
+        instance._netaudio_func_list.append(value)
+        instance._playing_func_list.append(value)
     try:
         input_func = instance._input_func_map_rev[value]
     except KeyError:
@@ -174,7 +178,8 @@ class DenonAVRInput(DenonAVRFoundation):
         ),
         default=attr.Factory(set),
     )
-    _callback_tasks: Set[asyncio.Task] = attr.ib(attr.Factory(set))
+    _callback_tasks: Set[asyncio.Task] = attr.ib(default=attr.Factory(set))
+    _netaudio_state: str = attr.ib(converter=fix_string, default="")
 
     # Update tags for attributes
     # AppCommand.xml interface
@@ -235,7 +240,7 @@ class DenonAVRInput(DenonAVRFoundation):
             self._unset_media_state()
             self._state = STATE_OFF
         elif self._schedule_media_updates():
-            self._state = STATE_PLAYING
+            self._state = STATE_ON
         else:
             self._unset_media_state()
             self._state = STATE_ON
@@ -287,7 +292,18 @@ class DenonAVRInput(DenonAVRFoundation):
         if self._input_func not in self._netaudio_func_list:
             return
 
-        if parameter.startswith("1"):
+        if parameter.startswith("0"):
+            if parameter[1:].startswith(NETAUDIO_PLAYING):
+                # It is not possible to see if the device is playing or paused.
+                # We assume it is playing first.
+                # Then, the state might be changed by async_play, async_pause
+                # and async_stop.
+                if self._state not in {STATE_PLAYING, STATE_PAUSED, STATE_STOPPED}:
+                    self._state = STATE_PLAYING
+            else:
+                self._state = STATE_STOPPED
+            self._netaudio_state = parameter[1:]
+        elif parameter.startswith("1"):
             self._title = parameter[1:]
         elif parameter.startswith("2"):
             self._artist = parameter[1:]
@@ -532,7 +548,7 @@ class DenonAVRInput(DenonAVRFoundation):
 
         self._replace_duplicate_sources(renamed_sources)
 
-        return (renamed_sources, deleted_sources)
+        return renamed_sources, deleted_sources
 
     async def async_get_changed_sources_status_xml(
         self, cache_id: Optional[Hashable] = None
@@ -622,7 +638,7 @@ class DenonAVRInput(DenonAVRFoundation):
 
         self._replace_duplicate_sources(renamed_sources)
 
-        return (renamed_sources, deleted_sources)
+        return renamed_sources, deleted_sources
 
     async def async_update_inputfuncs(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
@@ -821,6 +837,7 @@ class DenonAVRInput(DenonAVRFoundation):
                 "_title": "./szLine/value[2]",
                 "_artist": "./szLine/value[3]",
                 "_album": "./szLine/value[5]",
+                "_netaudio_state": "./szLine/value[1]",
             }
             self._band = None
             self._frequency = None
@@ -870,8 +887,16 @@ class DenonAVRInput(DenonAVRFoundation):
                 port=self._device.api.port,
                 hash=hash((self._title, self._artist, self._album)),
             )
-            # On track change assume device is PLAYING
-            self._state = STATE_PLAYING
+
+        if self._netaudio_state.startswith(NETAUDIO_PLAYING):
+            # It is not possible to see if the device is playing or paused.
+            # We assume it is playing first.
+            # Then, the state might be changed by async_play, async_pause
+            # and async_stop.
+            if self._state not in {STATE_PLAYING, STATE_PAUSED, STATE_STOPPED}:
+                self._state = STATE_PLAYING
+        else:
+            self._state = STATE_STOPPED
 
         await self._async_test_image_accessible()
 
@@ -1078,13 +1103,9 @@ class DenonAVRInput(DenonAVRFoundation):
             await self.async_play()
 
     async def async_play(self) -> None:
-        """Send play command to receiver command via HTTP post."""
+        """Send play command to receiver command."""
         # Use pause command only for sources which support NETAUDIO
         if self._input_func in self._netaudio_func_list:
-            # In fact play command is a play/pause toggle. Thus checking state
-            if self._state == STATE_PLAYING:
-                _LOGGER.info("Already playing, play command not sent")
-                return
             if self._device.telnet_available:
                 await self._device.telnet_api.async_send_commands(
                     self._device.telnet_commands.command_play
@@ -1094,12 +1115,12 @@ class DenonAVRInput(DenonAVRFoundation):
             self._state = STATE_PLAYING
 
     async def async_pause(self) -> None:
-        """Send pause command to receiver command via HTTP post."""
+        """Send pause command to receiver command."""
         # Use pause command only for sources which support NETAUDIO
         if self._input_func in self._netaudio_func_list:
             if self._device.telnet_available:
                 await self._device.telnet_api.async_send_commands(
-                    self._device.telnet_commands.command_play
+                    self._device.telnet_commands.command_pause
                 )
             else:
                 await self._device.api.async_get_command(
@@ -1107,8 +1128,20 @@ class DenonAVRInput(DenonAVRFoundation):
                 )
             self._state = STATE_PAUSED
 
+    async def async_stop(self) -> None:
+        """Send stop command to receiver command."""
+        # Use stop command only for sources which support NETAUDIO
+        if self._input_func in self._netaudio_func_list:
+            if self._device.telnet_available:
+                await self._device.telnet_api.async_send_commands(
+                    self._device.telnet_commands.command_stop
+                )
+            else:
+                await self._device.api.async_get_command(self._device.urls.command_stop)
+            self._state = STATE_STOPPED
+
     async def async_previous_track(self) -> None:
-        """Send previous track command to receiver command via HTTP post."""
+        """Send previous track command to receiver command."""
         # Use previous track button only for sources which support NETAUDIO
         if self._input_func in self._netaudio_func_list:
             body = {
@@ -1121,7 +1154,7 @@ class DenonAVRInput(DenonAVRFoundation):
             )
 
     async def async_next_track(self) -> None:
-        """Send next track command to receiver command via HTTP post."""
+        """Send next track command to receiver command."""
         # Use next track button only for sources which support NETAUDIO
         if self._input_func in self._netaudio_func_list:
             body = {

denonavr/soundmode.py

@@ -19,18 +19,18 @@ 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_LABELS,
+    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_LABELS,
+    MDAX_MAP_REVERSE,
     SOUND_MODE_MAPPING,
     Auro3DModes,
     AuroMatic3DPresets,
@@ -125,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(
@@ -146,17 +146,18 @@ 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(str), default=None
+        converter=attr.converters.optional(MDAX_MAP.get), default=None
     )
     _mdaxs = get_args(MDAXs)
     _dac_filter: Optional[str] = attr.ib(
-        converter=attr.converters.optional(str), default=None
+        converter=attr.converters.optional(DAC_FILTERS_MAP.get), default=None
     )
     _dac_filters = get_args(DACFilters)
     _sound_mode_map: Dict[str, list] = attr.ib(
@@ -264,9 +265,9 @@ 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":
@@ -292,9 +293,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
     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:]
 
     def _auro_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Auro change event."""
@@ -303,11 +302,11 @@ class DenonAVRSoundMode(DenonAVRFoundation):
             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:]
 
     def _dialog_control_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a Dialog Control change event."""
@@ -315,7 +314,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if len(key_value) != 2 or key_value[0] != "DIC":
             return
 
-        self._dialog_control = int(key_value[1])
+        self._dialog_control = key_value[1]
 
     def _speaker_virtualizer_callback(
         self, zone: str, event: str, parameter: str
@@ -335,9 +334,7 @@ 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]
 
     def _drc_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a DRC change event."""
@@ -353,7 +350,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if len(key_value) != 2 or key_value[0] != "MDAX":
             return
 
-        self._mdax = MDAX_MAP_LABELS[key_value[1]]
+        self._mdax = key_value[1]
 
     def _dac_filter_callback(self, zone: str, event: str, parameter: str) -> None:
         """Handle a DAC Filter change event."""
@@ -361,7 +358,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if len(key_value) != 2 or key_value[0] != "DACFIL":
             return
 
-        self._dac_filter = DAC_FILTERS_MAP_LABELS[key_value[1]]
+        self._dac_filter = key_value[1]
 
     async def async_update(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
@@ -1057,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(
@@ -1074,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(
@@ -1142,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(
@@ -1239,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(
@@ -1279,7 +1276,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if mode not in self._mdaxs:
             raise AvrCommandError(f"{mode} is not a valid M-DAX mode")
 
-        local_mode = MDAX_MAP[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)
@@ -1301,7 +1298,7 @@ class DenonAVRSoundMode(DenonAVRFoundation):
         if mode not in self._dac_filters:
             raise AvrCommandError(f"{mode} is not a valid DAC Filter mode")
 
-        local_mode = DAC_FILTERS_MAP[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)
@@ -1311,6 +1308,23 @@ class DenonAVRSoundMode(DenonAVRFoundation):
                 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/volume.py

@@ -16,14 +16,14 @@ import attr
 from .appcommand import AppCommands
 from .const import (
     CHANNEL_MAP,
-    CHANNEL_MAP_LABELS,
+    CHANNEL_MAP_REVERSE,
     CHANNEL_VOLUME_MAP,
-    CHANNEL_VOLUME_MAP_LABELS,
+    CHANNEL_VOLUME_MAP_REVERSE,
     DENON_ATTR_SETATTR,
     MAIN_ZONE,
     STATE_ON,
     SUBWOOFERS_MAP,
-    SUBWOOFERS_MAP_LABELS,
+    SUBWOOFERS_MAP_REVERSE,
     Channels,
     Subwoofers,
 )
@@ -119,7 +119,7 @@ class DenonAVRVolume(DenonAVRFoundation):
         channel_volume = parameter.split()
         if (
             len(channel_volume) != 2
-            or channel_volume[0] not in CHANNEL_MAP_LABELS
+            or channel_volume[0] not in CHANNEL_MAP
             or channel_volume[1] not in CHANNEL_VOLUME_MAP
         ):
             return
@@ -127,7 +127,7 @@ class DenonAVRVolume(DenonAVRFoundation):
         if self._channel_volumes is None:
             self._channel_volumes = {}
 
-        channel = CHANNEL_MAP_LABELS[channel_volume[0]]
+        channel = CHANNEL_MAP[channel_volume[0]]
         volume = channel_volume[1]
         self._channel_volumes[channel] = CHANNEL_VOLUME_MAP[volume]
 
@@ -142,16 +142,13 @@ class DenonAVRVolume(DenonAVRFoundation):
             return
 
         subwoofer_volume = parameter.split()
-        if (
-            len(subwoofer_volume) != 2
-            or subwoofer_volume[0] not in SUBWOOFERS_MAP_LABELS
-        ):
+        if len(subwoofer_volume) != 2 or subwoofer_volume[0] not in SUBWOOFERS_MAP:
             return
 
         if self._subwoofer_levels is None:
             self._subwoofer_levels = {}
 
-        subwoofer = SUBWOOFERS_MAP_LABELS[subwoofer_volume[0]]
+        subwoofer = SUBWOOFERS_MAP[subwoofer_volume[0]]
         level = subwoofer_volume[1]
         val = convert_on_off_bool(level)
         if val is not None:
@@ -306,7 +303,7 @@ class DenonAVRVolume(DenonAVRFoundation):
     # Setter #
     ##########
     async def async_volume_up(self) -> None:
-        """Volume up receiver via HTTP get command."""
+        """Volume up receiver."""
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_volume_up, skip_confirmation=True
@@ -317,7 +314,7 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_volume_down(self) -> None:
-        """Volume down receiver via HTTP get command."""
+        """Volume down receiver."""
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_volume_down, skip_confirmation=True
@@ -329,7 +326,7 @@ class DenonAVRVolume(DenonAVRFoundation):
 
     async def async_set_volume(self, volume: float) -> None:
         """
-        Set receiver volume via HTTP get command.
+        Set receiver volume.
 
         Volume is send in a format like -50.0.
         Minimum is -80.0, maximum at 18.0
@@ -351,7 +348,7 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_mute(self, mute: bool) -> None:
-        """Mute receiver via HTTP get command."""
+        """Mute receiver."""
         if mute:
             if self._device.telnet_available:
                 await self._device.telnet_api.async_send_commands(
@@ -372,10 +369,10 @@ class DenonAVRVolume(DenonAVRFoundation):
                 )
 
     async def async_channel_volume_up(self, channel: Channels) -> None:
-        """Increase Channel volume on receiver via HTTP get command."""
+        """Increase Channel volume on receiver."""
         self._is_valid_channel(channel)
 
-        mapped_channel = CHANNEL_MAP[channel]
+        mapped_channel = CHANNEL_MAP_REVERSE[channel]
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_channel_volume.format(
@@ -390,10 +387,10 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_channel_volume_down(self, channel: Channels) -> None:
-        """Decrease Channel volume on receiver via HTTP get command."""
+        """Decrease Channel volume on receiver."""
         self._is_valid_channel(channel)
 
-        mapped_channel = CHANNEL_MAP[channel]
+        mapped_channel = CHANNEL_MAP_REVERSE[channel]
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_channel_volume.format(
@@ -409,17 +406,17 @@ class DenonAVRVolume(DenonAVRFoundation):
 
     async def async_channel_volume(self, channel: Channels, volume: float) -> None:
         """
-        Set Channel volume on receiver via HTTP get command.
+        Set Channel volume on receiver.
 
         :param channel: Channel to set.
         :param volume: Volume to set. Valid values are -12 to 12 with 0.5 steps.
         """
         self._is_valid_channel(channel)
-        if volume not in CHANNEL_VOLUME_MAP_LABELS:
+        if volume not in CHANNEL_VOLUME_MAP_REVERSE:
             raise AvrCommandError(f"Invalid channel volume: {volume}")
 
-        mapped_channel = CHANNEL_MAP[channel]
-        mapped_volume = CHANNEL_VOLUME_MAP_LABELS[volume]
+        mapped_channel = CHANNEL_MAP_REVERSE[channel]
+        mapped_volume = CHANNEL_VOLUME_MAP_REVERSE[volume]
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_channel_volume.format(
@@ -434,7 +431,7 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_channel_volumes_reset(self) -> None:
-        """Reset all channel volumes on receiver via HTTP get command."""
+        """Reset all channel volumes on receiver."""
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_channel_volumes_reset
@@ -445,7 +442,7 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_subwoofer_on(self) -> None:
-        """Turn on Subwoofer on receiver via HTTP get command."""
+        """Turn on Subwoofer on receiver."""
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_subwoofer_on_off.format(mode="ON")
@@ -456,7 +453,7 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_subwoofer_off(self) -> None:
-        """Turn off Subwoofer on receiver via HTTP get command."""
+        """Turn off Subwoofer on receiver."""
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_subwoofer_on_off.format(mode="OFF")
@@ -468,7 +465,7 @@ class DenonAVRVolume(DenonAVRFoundation):
 
     async def async_subwoofer_toggle(self) -> None:
         """
-        Toggle Subwoofer on receiver via HTTP get command.
+        Toggle Subwoofer on receiver.
 
         Only available if using Telnet.
         """
@@ -478,9 +475,9 @@ class DenonAVRVolume(DenonAVRFoundation):
             await self.async_subwoofer_on()
 
     async def async_subwoofer_level_up(self, subwoofer: Subwoofers) -> None:
-        """Increase Subwoofer level on receiver via HTTP get command."""
+        """Increase Subwoofer level on receiver."""
         self._is_valid_subwoofer(subwoofer)
-        mapped_subwoofer = SUBWOOFERS_MAP[subwoofer]
+        mapped_subwoofer = SUBWOOFERS_MAP_REVERSE[subwoofer]
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_subwoofer_level.format(
@@ -495,9 +492,9 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_subwoofer_level_down(self, subwoofer: Subwoofers) -> None:
-        """Decrease Subwoofer level on receiver via HTTP get command."""
+        """Decrease Subwoofer level on receiver."""
         self._is_valid_subwoofer(subwoofer)
-        mapped_subwoofer = SUBWOOFERS_MAP[subwoofer]
+        mapped_subwoofer = SUBWOOFERS_MAP_REVERSE[subwoofer]
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_subwoofer_level.format(
@@ -512,7 +509,7 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_lfe_up(self) -> None:
-        """Increase LFE on receiver via HTTP get command."""
+        """Increase LFE on receiver."""
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_lfe.format(mode="UP")
@@ -523,7 +520,7 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_lfe_down(self) -> None:
-        """Decrease LFE on receiver via HTTP get command."""
+        """Decrease LFE on receiver."""
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_lfe.format(mode="DOWN")
@@ -535,7 +532,7 @@ class DenonAVRVolume(DenonAVRFoundation):
 
     async def async_lfe(self, lfe: int) -> None:
         """
-        Set LFE level on receiver via HTTP get command.
+        Set LFE level on receiver.
 
         :param lfe: LFE level to set. Valid values are -10 to 0.
         """
@@ -553,7 +550,7 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_bass_sync_up(self) -> None:
-        """Increase Bass Sync on receiver via HTTP get command."""
+        """Increase Bass Sync on receiver."""
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_bass_sync.format(mode="UP")
@@ -564,7 +561,7 @@ class DenonAVRVolume(DenonAVRFoundation):
             )
 
     async def async_bass_sync_down(self) -> None:
-        """Decrease Bass Sync on receiver via HTTP get command."""
+        """Decrease Bass Sync on receiver."""
         if self._device.telnet_available:
             await self._device.telnet_api.async_send_commands(
                 self._device.telnet_commands.command_bass_sync.format(mode="DOWN")
@@ -576,7 +573,7 @@ class DenonAVRVolume(DenonAVRFoundation):
 
     async def async_bass_sync(self, lfe: int) -> None:
         """
-        Set Bass Sync level on receiver via HTTP get command.
+        Set Bass Sync level on receiver.
 
         :param lfe: Bass Sync level to set. Valid values are -10 to 0.
         """

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: denonavr
-Version: 1.2.0
+Version: 1.3.1
 Summary: Automation Library for Denon AVR receivers
 Author-email: Oliver Goetz <scarface@mywoh.de>
 License: MIT