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

denonavr/__init__.py

@@ -17,7 +17,7 @@ from .ssdp import async_identify_denonavr_receivers
 logging.getLogger(__name__).addHandler(logging.NullHandler())
 
 __title__ = "denonavr"
-__version__ = "1.1.1"
+__version__ = "1.2.0"
 
 
 async def async_discover():

denonavr/api.py

@@ -16,18 +16,7 @@ import xml.etree.ElementTree as ET
 from collections import defaultdict
 from collections.abc import Hashable
 from io import BytesIO
-from typing import (
-    Awaitable,
-    Callable,
-    Coroutine,
-    DefaultDict,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    cast,
-)
+from typing import Callable, DefaultDict, Dict, List, Optional, Set, Tuple, cast
 
 import attr
 import httpx
@@ -111,10 +100,11 @@ class HTTPXAsyncClient:
         """Call GET endpoint of Denon AVR receiver asynchronously."""
         client = self.client_getter()
         try:
-            res = await client.get(
-                url, timeout=httpx.Timeout(timeout, read=read_timeout)
-            )
-            res.raise_for_status()
+            async with client.stream(
+                "GET", url, timeout=httpx.Timeout(timeout, read=read_timeout)
+            ) as res:
+                res.raise_for_status()
+                await res.aread()
         finally:
             # Close the default AsyncClient but keep custom clients open
             if self.is_default_async_client():
@@ -137,13 +127,15 @@ class HTTPXAsyncClient:
         """Call GET endpoint of Denon AVR receiver asynchronously."""
         client = self.client_getter()
         try:
-            res = await client.post(
+            async with client.stream(
+                "POST",
                 url,
                 content=content,
                 data=data,
                 timeout=httpx.Timeout(timeout, read=read_timeout),
-            )
-            res.raise_for_status()
+            ) as res:
+                res.raise_for_status()
+                await res.aread()
         finally:
             # Close the default AsyncClient but keep custom clients open
             if self.is_default_async_client():
@@ -475,6 +467,7 @@ class DenonAVRTelnetApi:
 
     host: str = attr.ib(converter=str, default="localhost")
     timeout: float = attr.ib(converter=float, default=2.0)
+    is_denon: bool = attr.ib(converter=bool, default=True)
     _connection_enabled: bool = attr.ib(default=False)
     _last_message_time: float = attr.ib(default=-1.0)
     _connect_lock: asyncio.Lock = attr.ib(default=attr.Factory(asyncio.Lock))
@@ -484,7 +477,6 @@ class DenonAVRTelnetApi:
     _telnet_event_map: Dict[str, List] = attr.ib(
         default=attr.Factory(telnet_event_map_factory)
     )
-    _callback_tasks: Set[asyncio.Task] = attr.ib(attr.Factory(set))
     _send_lock: asyncio.Lock = attr.ib(default=attr.Factory(asyncio.Lock))
     _send_confirmation_timeout: float = attr.ib(converter=float, default=2.0)
     _send_confirmation_event: asyncio.Event = attr.ib(
@@ -492,20 +484,21 @@ class DenonAVRTelnetApi:
     )
     _send_confirmation_command: str = attr.ib(converter=str, default="")
     _send_tasks: Set[asyncio.Task] = attr.ib(attr.Factory(set))
-    _callbacks: Dict[str, List[Coroutine]] = attr.ib(
+    _callbacks: Dict[str, List[Callable]] = attr.ib(
         validator=attr.validators.instance_of(dict),
         default=attr.Factory(dict),
         init=False,
     )
-    _raw_callbacks: List[Coroutine] = attr.ib(
+    _raw_callbacks: List[Callable] = attr.ib(
         validator=attr.validators.instance_of(list),
         default=attr.Factory(list),
         init=False,
     )
+    _update_callback_tasks: Set[asyncio.Task] = attr.ib(attr.Factory(set))
 
     def __attrs_post_init__(self) -> None:
         """Initialize special attributes."""
-        self._register_raw_callback(self._async_send_confirmation_callback)
+        self._register_raw_callback(self._send_confirmation_callback)
 
     async def async_connect(self) -> None:
         """Connect to the receiver asynchronously."""
@@ -549,70 +542,97 @@ class DenonAVRTelnetApi:
         self._connection_enabled = True
         self._last_message_time = time.monotonic()
         self._schedule_monitor()
-        # Trigger update of all attributes
+
+        # Cancel all update tasks in case they are still running and create a new one.
+        for callback_task in self._update_callback_tasks:
+            callback_task.cancel()
+
+        task = asyncio.create_task(self._async_trigger_updates())
+        self._update_callback_tasks.add(task)
+        task.add_done_callback(self._update_callback_tasks.discard)
+
+    async def _async_trigger_updates(self) -> None:
+        """Trigger update of all attributes."""
+        commands = [
+            # Critical State Info
+            "ZM?",  # Main Zone Power
+            "SI?",  # Select INPUT source
+            "MV?",  # MASTER VOLUME
+            "MU?",  # Mute
+            "Z2?",  # Z2 Zone Power
+            "Z2MU?",  # Z2 Mute
+            "Z3?",  # Z3 Zone Power
+            "Z3MU?",  # Z3 Mute
+            "MS?",  # Surround mode
+            # State Info used in Toggle Commands
+            "MNMEN?",  # Menu
+            "TR?",  # Trigger
+            "PSTONE CTRL ?",  # TONE
+            "PSDYNEQ ?",  # Dynamic EQ
+            "PSLFC ?",  # Audyssey LFC
+            "PSNEURAL ?",  # Neural:X
+            "PSIMAXAUD ?",  # IMAX Audio Settings Auto/Manual
+            "PSIMAXSWM ?",  # IMAX Subwoofer Mode
+            "PSSWR ?",  # Subwoofer
+            "SSTTR ?",  # Tactile Transducer
+            "VSAUDIO ?",  # HDMI Audio Decode
+            "PSCES ?",  # CENTER Spread
+            "PSLOM ?",  # Loudness Management
+            "PSCINEMA EQ. ?",  # CINEMA EQ
+            "BTTX ?",  # Bluetooth Transmitter
+            "PSSPV ?",  # Speaker Virtualizer
+            "PSGEQ ?",  # Graphic EQ
+            "PSHEQ ?",  # Headphone EQ
+            # Regular State Info
+            "PSBAS ?",  # BASS
+            "PSTRE ?",  # TREBLE
+            "PSCNTAMT ?",  # Containment Amount
+            "PSMULTEQ: ?",  # MultEQ
+            "PSREFLEV ?",  # Reference Level
+            "PSDYNVOL ?",  # Dynamic Vol.
+            "DIM ?",  # Dimmer
+            "PSDELAY ?",  # Audio Delay
+            "ECO?",  # ECO
+            "VSMONI ?",  # HDMI Output
+            "PSDIRAC ?",  # Dirac Live Filter
+            "CV?",  # Channel Volume
+            "PSIMAX ?",  # IMAX
+            "PSIMAXHPF ?",  # IMAX High Pass Filter
+            "PSIMAXLPF ?",  # IMAX Low Pass Filter
+            "PSIMAXSWO ?",  # Subwoofer Output LFE+Main/LFE
+            "PSSWL ?",  # Subwoofer Level
+            "STBY?",  # Auto Standby
+            "SLP?",  # Sleep
+            "VSVPM ?",  # Video Process
+            "PSLFE ?",  # LFE Level
+            "PSBSC ?",  # Bass Sync
+            "PSDEH ?",  # Dialog Enhancer
+            "PSAUROPR ?",  # Auro-Matic Preset
+            "PSAUROST ?",  # Auro-Matic Strength
+            "PSAUROMODE ?",  # AURO-3D Mode
+            "PSRSZ ?",  # ROOM SIZE
+            "SPPR ?",  # Speaker Preset
+            "PSDIC ?",  # Dialog Control
+            "PSSP: ?",  # Effect Speaker selection
+            "PSDRC ?",  # DRC
+            "PSDEL ?",  # DELAY TIME
+            "PSRSTR ?",  # AUDIO RESTORER
+        ]
+
+        index = commands.index("MNMEN?")
+        if self.is_denon:
+            commands.insert(index := index + 1, "MSQUICK ?")  # Quick Select
+        if not self.is_denon:
+            commands.insert(index + 1, "MSSMART ?")  # SMART Select
+            index = commands.index("TR?")
+            commands.insert(index := index + 1, "PSMDAX ?")  # MDAX
+            commands.insert(index := index + 1, "PSDACFIL ?")  # DAC Filter
+            commands.insert(index := index + 1, "ILB ?")  # Illumination
+            commands.insert(index + 1, "SSHOS ?")  # Auto Lip Sync
+
         await self.async_send_commands(
-            "ZM?",
-            "SI?",
-            "MV?",
-            "MU?",
-            "Z2?",
-            "Z2MU?",
-            "Z3?",
-            "Z3MU?",
-            "PSTONE CTRL ?",
-            "PSBAS ?",
-            "PSTRE ?",
-            "PSDYNEQ ?",
-            "PSLFC ?",
-            "PSCNTAMT ?",
-            "PSMULTEQ: ?",
-            "PSREFLEV ?",
-            "PSDYNVOL ?",
-            "MS?",
-            "MNMEN?",
-            "DIM ?",
-            "PSDELAY?",
-            "ECO?",
-            "VSMONI ?",
-            "PSDIRAC ?",
-            "CV?",
-            "PSNEURAL ?",
-            "PSIMAX ?",
-            "PSIMAXAUD ?",
-            "PSIMAXHPF ?",
-            "PSIMAXLPF ?",
-            "PSIMAXSWM ?",
-            "PSIMAXSWO ?",
-            "PSSWR ?",
-            "PSSWL ?",
-            "SSTTR ?",
-            "MSQUICK ?",
-            "STBY?",
-            "SLP?",
-            "VSAUDIO ?",
-            "PSCES ?",
-            "VSVPM ?",
-            "PSLFE ?",
-            "PSLOM ?",
-            "PSBSC ?",
-            "PSDEH ?",
-            "PSCINEMA EQ. ?",
-            "PSAUROPR ?",
-            "PSAUROST ?",
-            "PSAUROMODE ?",
-            "PSRSZ ?",
-            "TR?",
-            "SPPR ?",
-            "BTTX ?",
-            "PSDIC ?",
-            "PSSPV ?",
-            "PSSP: ?",
-            "PSDRC ?",
-            "PSDEL ?",
-            "PSRSTR ?",
-            "PSGEQ ?",
-            "PSHEQ ?",
-            skip_confirmation=True,
+            *commands,
+            confirmation_timeout=0.2,
         )
 
     def _schedule_monitor(self) -> None:
@@ -712,7 +732,7 @@ class DenonAVRTelnetApi:
         self._reconnect_task = None
 
     def register_callback(
-        self, event: str, callback: Callable[[str, str, str], Awaitable[None]]
+        self, event: str, callback: Callable[[str, str, str], None]
     ) -> None:
         """Register a callback handler for an event type."""
         # Validate the passed in type
@@ -726,24 +746,20 @@ class DenonAVRTelnetApi:
         self._callbacks[event].append(callback)
 
     def unregister_callback(
-        self, event: str, callback: Callable[[str, str, str], Awaitable[None]]
+        self, event: str, callback: Callable[[str, str, str], None]
     ) -> None:
         """Unregister a callback handler for an event type."""
         if event not in self._callbacks.keys():
             return
         self._callbacks[event].remove(callback)
 
-    def _register_raw_callback(
-        self, callback: Callable[[str], Awaitable[None]]
-    ) -> None:
+    def _register_raw_callback(self, callback: Callable[[str], None]) -> None:
         """Register a callback handler for raw telnet messages."""
         if callback in self._raw_callbacks:
             return
         self._raw_callbacks.append(callback)
 
-    def _unregister_raw_callback(
-        self, callback: Callable[[str], Awaitable[None]]
-    ) -> None:
+    def _unregister_raw_callback(self, callback: Callable[[str], None]) -> None:
         """Unregister a callback handler for raw telnet messages."""
         self._raw_callbacks.remove(callback)
 
@@ -787,19 +803,15 @@ class DenonAVRTelnetApi:
         if event not in TELNET_EVENTS:
             return
 
-        task = asyncio.create_task(
-            self._async_run_callbacks(message, event, zone, parameter)
-        )
-        self._callback_tasks.add(task)
-        task.add_done_callback(self._callback_tasks.discard)
+        self._run_callbacks(message, event, zone, parameter)
 
-    async def _async_run_callbacks(
+    def _run_callbacks(
         self, message: str, event: str, zone: str, parameter: str
     ) -> None:
         """Handle triggering the registered callbacks."""
         for callback in self._raw_callbacks:
             try:
-                await callback(message)
+                callback(message)
             except Exception as err:  # pylint: disable=broad-except
                 # We don't want a single bad callback to trip up the
                 # whole system and prevent further execution
@@ -812,7 +824,7 @@ class DenonAVRTelnetApi:
         if event in self._callbacks.keys():
             for callback in self._callbacks[event]:
                 try:
-                    await callback(zone, event, parameter)
+                    callback(zone, event, parameter)
                 except Exception as err:  # pylint: disable=broad-except
                     # We don't want a single bad callback to trip up the
                     # whole system and prevent further execution
@@ -825,7 +837,7 @@ class DenonAVRTelnetApi:
         if ALL_TELNET_EVENTS in self._callbacks.keys():
             for callback in self._callbacks[ALL_TELNET_EVENTS]:
                 try:
-                    await callback(zone, event, parameter)
+                    callback(zone, event, parameter)
                 except Exception as err:  # pylint: disable=broad-except
                     # We don't want a single bad callback to trip up the
                     # whole system and prevent further execution
@@ -843,7 +855,7 @@ class DenonAVRTelnetApi:
                 return event
         return ""
 
-    async def _async_send_confirmation_callback(self, message: str) -> None:
+    def _send_confirmation_callback(self, message: str) -> None:
         """Confirm that the telnet command has been executed."""
         if len(message) < 3:
             return
@@ -854,9 +866,15 @@ class DenonAVRTelnetApi:
             _LOGGER.debug("Command %s confirmed", command)
 
     async def _async_send_command(
-        self, command: str, skip_confirmation: bool = False
+        self,
+        command: str,
+        skip_confirmation: bool = False,
+        confirmation_timeout: Optional[float] = None,
     ) -> None:
         """Send one telnet command to the receiver."""
+        if confirmation_timeout is None:
+            confirmation_timeout = self._send_confirmation_timeout
+
         async with self._send_lock:
             if not skip_confirmation:
                 self._send_confirmation_command = command
@@ -871,26 +889,42 @@ class DenonAVRTelnetApi:
                 try:
                     await asyncio.wait_for(
                         self._send_confirmation_event.wait(),
-                        self._send_confirmation_timeout,
+                        confirmation_timeout,
                     )
                 except asyncio.TimeoutError:
-                    _LOGGER.info(
+                    _LOGGER.debug(
                         "Timeout waiting for confirmation of command: %s", command
                     )
                 finally:
                     self._send_confirmation_command = ""
 
     async def async_send_commands(
-        self, *commands: str, skip_confirmation: bool = False
+        self,
+        *commands: str,
+        skip_confirmation: bool = False,
+        confirmation_timeout: Optional[float] = None,
     ) -> None:
         """Send telnet commands to the receiver."""
         for command in commands:
-            await self._async_send_command(command, skip_confirmation=skip_confirmation)
+            await self._async_send_command(
+                command,
+                skip_confirmation=skip_confirmation,
+                confirmation_timeout=confirmation_timeout,
+            )
 
-    def send_commands(self, *commands: str, skip_confirmation: bool = False) -> None:
+    def send_commands(
+        self,
+        *commands: str,
+        skip_confirmation: bool = False,
+        confirmation_timeout: Optional[float] = None,
+    ) -> None:
         """Send telnet commands to the receiver."""
         task = asyncio.create_task(
-            self.async_send_commands(*commands, skip_confirmation=skip_confirmation)
+            self.async_send_commands(
+                *commands,
+                skip_confirmation=skip_confirmation,
+                confirmation_timeout=confirmation_timeout,
+            )
         )
         self._send_tasks.add(task)
         task.add_done_callback(self._send_tasks.discard)

denonavr/audyssey.py

@@ -77,15 +77,11 @@ class DenonAVRAudyssey(DenonAVRFoundation):
         for tag in self.appcommand0300_attrs:
             self._device.api.add_appcommand0300_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
 
-    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