denonavr 0.11.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

denonavr/decorators.py

@@ -7,13 +7,12 @@ This module implements the REST API to Denon AVR receivers.
 :license: MIT, see LICENSE for more details.
 """
 
-import asyncio
 import inspect
 import logging
 import time
 import xml.etree.ElementTree as ET
 from functools import wraps
-from typing import Callable, Coroutine, TypeVar
+from typing import Callable, TypeVar
 
 import httpx
 from asyncstdlib import lru_cache
@@ -46,26 +45,21 @@ def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[...,
         try:
             return await func(*args, **kwargs)
         except httpx.HTTPStatusError as err:
-            _LOGGER.debug("HTTP status error on request %s", err.request, exc_info=True)
+            _LOGGER.debug("HTTP status error on request %s: %s", err.request, err)
             # Separate handling of 403 errors
             if err.response.status_code == 403:
                 raise AvrForbiddenError(f"HTTPStatusError: {err}", err.request) from err
             raise AvrRequestError(f"HTTPStatusError: {err}", err.request) from err
         except httpx.TimeoutException as err:
-            _LOGGER.debug(
-                "HTTP timeout exception on request %s", err.request, exc_info=True
-            )
+            _LOGGER.debug("HTTP timeout exception on request %s: %s", err.request, err)
             raise AvrTimoutError(f"TimeoutException: {err}", err.request) from err
         except httpx.NetworkError as err:
-            _LOGGER.debug(
-                "Network error exception on request %s", err.request, exc_info=True
-            )
+            _LOGGER.debug("Network error exception on request %s: %s", err.request, err)
             raise AvrNetworkError(f"NetworkError: {err}", err.request) from err
         except httpx.RemoteProtocolError as err:
             _LOGGER.debug(
                 "Remote protocol error exception on request %s",
                 err.request,
-                exc_info=True,
             )
             raise AvrInvalidResponseError(
                 f"RemoteProtocolError: {err}", err.request
@@ -77,7 +71,7 @@ def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[...,
             UnicodeDecodeError,
         ) as err:
             _LOGGER.debug(
-                "Defusedxml parse error on request %s", (args, kwargs), exc_info=True
+                "Defusedxml parse error on request %s: %s", (args, kwargs), err
             )
             raise AvrInvalidResponseError(
                 f"XMLParseError: {err}", (args, kwargs)
@@ -110,42 +104,8 @@ def cache_result(func: Callable[..., AnyT]) -> Callable[..., AnyT]:
         try:
             return await cached_func(*args, **kwargs)
         except Exception as err:
-            _LOGGER.debug("Exception %s raised, clearing cache", err)
+            _LOGGER.debug("Exception raised, clearing cache: %s", err)
             cached_func.cache_clear()
             raise
 
     return wrapper
-
-
-def run_async_synchronously(async_func: Coroutine) -> Callable:
-    """
-    Decorate to run the configured asynchronous function synchronously instead.
-
-    If available the corresponding function with async_ prefix is called in an
-    own event loop. This is not efficient but it ensures backwards
-    compatibility of this library.
-    """
-
-    def decorator(func: Callable):
-        # Check if function is a coroutine
-        if not inspect.iscoroutinefunction(async_func):
-            raise AttributeError(f"Function {async_func} is not a coroutine function")
-        # Check if the signature of both functions is equal
-        if inspect.signature(func) != inspect.signature(async_func):
-            raise AttributeError(
-                f"Functions {func} and {async_func} have different signatures"
-            )
-
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            # Run async function in own event loop
-            loop = asyncio.new_event_loop()
-
-            try:
-                return loop.run_until_complete(async_func(*args, **kwargs))
-            finally:
-                loop.close()
-
-        return wrapper
-
-    return decorator

denonavr/denonavr.py

@@ -17,7 +17,6 @@ import httpx
 
 from .audyssey import DenonAVRAudyssey, audyssey_factory
 from .const import DENON_ATTR_SETATTR, MAIN_ZONE, VALID_ZONES
-from .decorators import run_async_synchronously
 from .exceptions import AvrCommandError
 from .foundation import DenonAVRFoundation, set_api_host, set_api_timeout
 from .input import DenonAVRInput, input_factory
@@ -138,6 +137,7 @@ class DenonAVR(DenonAVRFoundation):
     async def async_setup(self) -> None:
         """Ensure that configuration is loaded from receiver asynchronously."""
         async with self._setup_lock:
+            _LOGGER.debug("Starting denonavr setup")
             # Device setup
             await self._device.async_setup()
             if self._name is None:
@@ -146,7 +146,7 @@ class DenonAVR(DenonAVRFoundation):
             # Setup other functions
             self.input.setup()
             await self.soundmode.async_setup()
-            self.tonecontrol.setup()
+            await self.tonecontrol.async_setup()
             self.vol.setup()
             self.audyssey.setup()
 
@@ -155,10 +155,7 @@ class DenonAVR(DenonAVRFoundation):
                     await zone_item.async_setup()
 
             self._is_setup = True
-
-    @run_async_synchronously(async_func=async_setup)
-    def setup(self) -> None:
-        """Ensure that configuration is loaded from receiver."""
+            _LOGGER.debug("Finished denonavr setup")
 
     async def async_update(self):
         """
@@ -166,6 +163,7 @@ class DenonAVR(DenonAVRFoundation):
 
         Method executes the update method for the current receiver type.
         """
+        _LOGGER.debug("Starting denonavr update")
         # Ensure that the device is setup
         if not self._is_setup:
             await self.async_setup()
@@ -174,6 +172,7 @@ class DenonAVR(DenonAVRFoundation):
         cache_id = time.time()
 
         # Verify update method
+        _LOGGER.debug("Verifying update method")
         await self._device.async_verify_avr_2016_update_method(cache_id=cache_id)
 
         # Update device
@@ -189,43 +188,20 @@ class DenonAVR(DenonAVRFoundation):
         # into main update
         # await self.audyssey.async_update(
         #     global_update=True, cache_id=cache_id)
-
-    @run_async_synchronously(async_func=async_update)
-    def update(self):
-        """
-        Get the latest status information from device.
-
-        Method executes the update method for the current receiver type.
-        """
+        _LOGGER.debug("Finished denonavr update")
 
     async def async_update_tonecontrol(self):
         """Get Tonecontrol settings."""
         await self.tonecontrol.async_update()
 
-    @run_async_synchronously(async_func=async_update_tonecontrol)
-    def update_tonecontrol(self):
-        """Get Tonecontrol settings."""
-
     async def async_update_audyssey(self):
         """Get Audyssey settings."""
         await self.audyssey.async_update()
 
-    @run_async_synchronously(async_func=async_update_audyssey)
-    def update_audyssey(self):
-        """Get Audyssey settings."""
-
     async def async_get_command(self, request: str) -> str:
         """Send HTTP GET command to Denon AVR receiver asynchronously."""
         return await self._device.api.async_get_command(request)
 
-    @run_async_synchronously(async_func=async_get_command)
-    def get_command(self, request: str) -> str:
-        """Send HTTP GET command to Denon AVR receiver."""
-
-    @run_async_synchronously(async_func=async_get_command)
-    def send_get_command(self, request: str) -> str:
-        """Send HTTP GET command to Denon AVR receiver...for compatibility."""
-
     async def async_send_telnet_commands(self, *commands: str) -> None:
         """Send telnet commands to the receiver."""
         await self._device.telnet_api.async_send_commands(*commands)
@@ -344,7 +320,7 @@ class DenonAVR(DenonAVRFoundation):
 
     @property
     def support_sound_mode(self) -> Optional[bool]:
-        """Return True if sound mode supported."""
+        """Return True if sound mode is supported."""
         return self.soundmode.support_sound_mode
 
     @property
@@ -459,6 +435,11 @@ class DenonAVR(DenonAVRFoundation):
         """Indicate if all inputs are shown or just active one."""
         return self._show_all_inputs
 
+    @property
+    def support_tone_control(self) -> Optional[bool]:
+        """Return True if tone control is supported."""
+        return self.tonecontrol.support_tone_control
+
     @property
     def tone_control_status(self) -> Optional[bool]:
         """Return value of tone control status."""
@@ -544,50 +525,26 @@ class DenonAVR(DenonAVRFoundation):
         """Turn DynamicEQ off."""
         await self.audyssey.async_dynamiceq_off()
 
-    @run_async_synchronously(async_func=async_dynamic_eq_off)
-    def dynamic_eq_off(self) -> None:
-        """Turn DynamicEQ off."""
-
     async def async_dynamic_eq_on(self) -> None:
         """Turn DynamicEQ on."""
         await self.audyssey.async_dynamiceq_on()
 
-    @run_async_synchronously(async_func=async_dynamic_eq_on)
-    def dynamic_eq_on(self) -> None:
-        """Turn DynamicEQ on."""
-
     async def async_toggle_dynamic_eq(self) -> None:
         """Toggle DynamicEQ."""
         await self.audyssey.async_toggle_dynamic_eq()
 
-    @run_async_synchronously(async_func=async_toggle_dynamic_eq)
-    def toggle_dynamic_eq(self) -> None:
-        """Toggle DynamicEQ."""
-
     async def async_set_multieq(self, value: str) -> None:
         """Set MultiEQ mode."""
         await self.audyssey.async_set_multieq(value)
 
-    @run_async_synchronously(async_func=async_set_multieq)
-    def set_multieq(self, value: str) -> None:
-        """Set MultiEQ mode."""
-
     async def async_set_reflevoffset(self, value: str) -> None:
         """Set Reference Level Offset."""
         await self.audyssey.async_set_reflevoffset(value)
 
-    @run_async_synchronously(async_func=async_set_reflevoffset)
-    def set_reflevoffset(self, value: str) -> None:
-        """Set Reference Level Offset."""
-
     async def async_set_dynamicvol(self, value: str) -> None:
         """Set Dynamic Volume."""
         await self.audyssey.async_set_dynamicvol(value)
 
-    @run_async_synchronously(async_func=async_set_dynamicvol)
-    def set_dynamicvol(self, value: str) -> None:
-        """Set Dynamic Volume."""
-
     async def async_set_input_func(self, input_func: str) -> None:
         """
         Set input_func of device.
@@ -597,15 +554,6 @@ class DenonAVR(DenonAVRFoundation):
         """
         await self.input.async_set_input_func(input_func)
 
-    @run_async_synchronously(async_func=async_set_input_func)
-    def set_input_func(self, input_func: str) -> None:
-        """
-        Set input_func of device.
-
-        Valid values depend on the device and should be taken from
-        "input_func_list".
-        """
-
     async def async_set_sound_mode(self, sound_mode: str) -> None:
         """
         Set sound_mode of device.
@@ -615,87 +563,42 @@ class DenonAVR(DenonAVRFoundation):
         """
         await self.soundmode.async_set_sound_mode(sound_mode)
 
-    @run_async_synchronously(async_func=async_set_sound_mode)
-    def set_sound_mode(self, sound_mode: str) -> None:
-        """
-        Set sound_mode of device.
-
-        Valid values depend on the device and should be taken from
-        "sound_mode_list".
-        """
-
     async def async_toggle_play_pause(self) -> None:
         """Toggle play pause media player."""
         await self.input.async_toggle_play_pause()
 
-    @run_async_synchronously(async_func=async_toggle_play_pause)
-    def toggle_play_pause(self) -> None:
-        """Toggle play pause media player."""
-
     async def async_play(self) -> None:
         """Send play command to receiver command via HTTP post."""
         await self.input.async_play()
 
-    @run_async_synchronously(async_func=async_play)
-    def play(self) -> None:
-        """Send play command to receiver command via HTTP post."""
-
     async def async_pause(self) -> None:
         """Send pause command to receiver command via HTTP post."""
         await self.input.async_pause()
 
-    @run_async_synchronously(async_func=async_pause)
-    def pause(self) -> None:
-        """Send pause command to receiver command via HTTP post."""
-
     async def async_previous_track(self) -> None:
         """Send previous track command to receiver command via HTTP post."""
         await self.input.async_previous_track()
 
-    @run_async_synchronously(async_func=async_previous_track)
-    def previous_track(self) -> None:
-        """Send previous track command to receiver command via HTTP post."""
-
     async def async_next_track(self) -> None:
         """Send next track command to receiver command via HTTP post."""
         await self.input.async_next_track()
 
-    @run_async_synchronously(async_func=async_next_track)
-    def next_track(self) -> None:
-        """Send next track command to receiver command via HTTP post."""
-
     async def async_power_on(self) -> None:
         """Turn on receiver via HTTP get command."""
         await self._device.async_power_on()
 
-    @run_async_synchronously(async_func=async_power_on)
-    def power_on(self) -> None:
-        """Turn on receiver via HTTP get command."""
-
     async def async_power_off(self) -> None:
         """Turn off receiver via HTTP get command."""
         await self._device.async_power_off()
 
-    @run_async_synchronously(async_func=async_power_off)
-    def power_off(self) -> None:
-        """Turn off receiver via HTTP get command."""
-
     async def async_volume_up(self) -> None:
         """Volume up receiver via HTTP get command."""
         await self.vol.async_volume_up()
 
-    @run_async_synchronously(async_func=async_volume_up)
-    def volume_up(self) -> None:
-        """Volume up receiver via HTTP get command."""
-
     async def async_volume_down(self) -> None:
         """Volume down receiver via HTTP get command."""
         await self.vol.async_volume_down()
 
-    @run_async_synchronously(async_func=async_volume_down)
-    def volume_down(self) -> None:
-        """Volume down receiver via HTTP get command."""
-
     async def async_set_volume(self, volume: float) -> None:
         """
         Set receiver volume via HTTP get command.
@@ -705,39 +608,18 @@ class DenonAVR(DenonAVRFoundation):
         """
         await self.vol.async_set_volume(volume)
 
-    @run_async_synchronously(async_func=async_set_volume)
-    def set_volume(self, volume: float) -> None:
-        """
-        Set receiver volume via HTTP get command.
-
-        Volume is send in a format like -50.0.
-        Minimum is -80.0, maximum at 18.0
-        """
-
     async def async_mute(self, mute: bool) -> None:
         """Mute receiver via HTTP get command."""
         await self.vol.async_mute(mute)
 
-    @run_async_synchronously(async_func=async_mute)
-    def mute(self, mute: bool) -> None:
-        """Mute receiver via HTTP get command."""
-
     async def async_enable_tone_control(self) -> None:
         """Enable tone control to change settings like bass or treble."""
         await self.tonecontrol.async_enable_tone_control()
 
-    @run_async_synchronously(async_func=async_enable_tone_control)
-    def enable_tone_control(self) -> None:
-        """Enable tone control to change settings like bass or treble."""
-
     async def async_disable_tone_control(self) -> None:
         """Disable tone control to change settings like bass or treble."""
         await self.tonecontrol.async_disable_tone_control()
 
-    @run_async_synchronously(async_func=async_disable_tone_control)
-    def disable_tone_control(self) -> None:
-        """Disable tone control to change settings like bass or treble."""
-
     async def async_set_bass(self, value: int) -> None:
         """
         Set receiver bass.
@@ -749,17 +631,6 @@ class DenonAVR(DenonAVRFoundation):
         """
         await self.tonecontrol.async_set_bass(value)
 
-    @run_async_synchronously(async_func=async_set_bass)
-    def set_bass(self, value: int) -> None:
-        """
-        Set receiver bass.
-
-        Minimum is 0, maximum at 12
-
-        Note:
-        Doesn't work, if Dynamic Equalizer is active.
-        """
-
     async def async_bass_up(self) -> None:
         """
         Increase level of Bass.
@@ -769,15 +640,6 @@ class DenonAVR(DenonAVRFoundation):
         """
         await self.tonecontrol.async_bass_up()
 
-    @run_async_synchronously(async_func=async_bass_up)
-    def bass_up(self) -> None:
-        """
-        Increase level of Bass.
-
-        Note:
-        Doesn't work, if Dynamic Equalizer is active
-        """
-
     async def async_bass_down(self) -> None:
         """
         Decrease level of Bass.
@@ -787,15 +649,6 @@ class DenonAVR(DenonAVRFoundation):
         """
         await self.tonecontrol.async_bass_down()
 
-    @run_async_synchronously(async_func=async_bass_down)
-    def bass_down(self) -> None:
-        """
-        Decrease level of Bass.
-
-        Note:
-        Doesn't work, if Dynamic Equalizer is active
-        """
-
     async def async_set_treble(self, value: int) -> None:
         """
         Set receiver treble.
@@ -807,17 +660,6 @@ class DenonAVR(DenonAVRFoundation):
         """
         await self.tonecontrol.async_set_treble(value)
 
-    @run_async_synchronously(async_func=async_set_treble)
-    def set_treble(self, value: int) -> None:
-        """
-        Set receiver treble.
-
-        Minimum is 0, maximum at 12
-
-        Note:
-        Doesn't work, if Dynamic Equalizer is active.
-        """
-
     async def async_treble_up(self) -> None:
         """
         Increase level of Treble.
@@ -827,15 +669,6 @@ class DenonAVR(DenonAVRFoundation):
         """
         await self.tonecontrol.async_treble_up()
 
-    @run_async_synchronously(async_func=async_treble_up)
-    def treble_up(self) -> None:
-        """
-        Increase level of Treble.
-
-        Note:
-        Doesn't work, if Dynamic Equalizer is active
-        """
-
     async def async_treble_down(self) -> None:
         """
         Decrease level of Treble.
@@ -845,11 +678,38 @@ class DenonAVR(DenonAVRFoundation):
         """
         await self.tonecontrol.async_treble_down()
 
-    @run_async_synchronously(async_func=async_treble_down)
-    def treble_down(self) -> None:
-        """
-        Decrease level of Treble.
+    async def async_cursor_up(self) -> None:
+        """Send cursor up to receiver via HTTP get command."""
+        await self._device.async_cursor_up()
 
-        Note:
-        Doesn't work, if Dynamic Equalizer is active
-        """
+    async def async_cursor_down(self) -> None:
+        """Send cursor down to receiver via HTTP get command."""
+        await self._device.async_cursor_down()
+
+    async def async_cursor_left(self) -> None:
+        """Send cursor left to receiver via HTTP get command."""
+        await self._device.async_cursor_left()
+
+    async def async_cursor_right(self) -> None:
+        """Send cursor right to receiver via HTTP get command."""
+        await self._device.async_cursor_right()
+
+    async def async_cursor_enter(self) -> None:
+        """Send cursor enter to receiver via HTTP get command."""
+        await self._device.async_cursor_enter()
+
+    async def async_back(self) -> None:
+        """Send back to receiver via HTTP get command."""
+        await self._device.async_back()
+
+    async def async_info(self) -> None:
+        """Send info to receiver via HTTP get command."""
+        await self._device.async_info()
+
+    async def async_options(self) -> None:
+        """Raise options menu to receiver via HTTP get command."""
+        await self._device.async_options()
+
+    async def async_settings_menu(self) -> None:
+        """Raise settings menu to receiver via HTTP get command."""
+        await self._device.async_settings_menu()