denonavr 0.11.6__py3-none-any.whl → 1.0.1__py3-none-any.whl

denonavr/__init__.py

@@ -10,8 +10,6 @@ Automation Library for Denon AVR receivers.
 # Set default logging handler to avoid "No handler found" warnings.
 import logging
 
-from .decorators import run_async_synchronously
-
 # Import denonavr module
 from .denonavr import DenonAVR
 from .ssdp import async_identify_denonavr_receivers
@@ -19,7 +17,7 @@ from .ssdp import async_identify_denonavr_receivers
 logging.getLogger(__name__).addHandler(logging.NullHandler())
 
 __title__ = "denonavr"
-__version__ = "0.11.6"
+__version__ = "1.0.1"
 
 
 async def async_discover():
@@ -33,17 +31,6 @@ async def async_discover():
     return await async_identify_denonavr_receivers()
 
 
-@run_async_synchronously(async_func=async_discover)
-def discover():
-    """
-    Discover all Denon AVR devices in LAN zone.
-
-    Returns a list of dictionaries which includes all discovered Denon AVR
-    devices with keys "host", "modelName", "friendlyName", "presentationURL".
-    By default SSDP broadcasts are sent once with a 2 seconds timeout.
-    """
-
-
 async def async_init_all_receivers():
     """
     Initialize all discovered Denon AVR receivers in LAN zone.
@@ -58,13 +45,3 @@ async def async_init_all_receivers():
         init_receiver = DenonAVR(receiver["host"])
         init_receivers.append(init_receiver)
     return init_receivers
-
-
-@run_async_synchronously(async_func=async_init_all_receivers)
-def init_all_receivers():
-    """
-    Initialize all discovered Denon AVR receivers in LAN zone.
-
-    Returns a list of created Denon AVR instances.
-    By default SSDP broadcasts are sent up to 3 times with a 2 seconds timeout.
-    """

denonavr/api.py

@@ -31,7 +31,8 @@ from typing import (
 
 import attr
 import httpx
-from defusedxml.ElementTree import fromstring
+from defusedxml import DefusedXmlException
+from defusedxml.ElementTree import ParseError, fromstring
 
 from .appcommand import AppCommandCmd
 from .const import (
@@ -83,16 +84,86 @@ def telnet_event_map_factory() -> Dict[str, List]:
     return dict(event_map)
 
 
-@attr.s(auto_attribs=True, hash=False, on_setattr=DENON_ATTR_SETATTR)
+@attr.s(auto_attribs=True, hash=False)
+class HTTPXAsyncClient:
+    """Perform cached HTTP calls with httpx.AsyncClient."""
+
+    client_getter: Callable[[], httpx.AsyncClient] = attr.ib(
+        validator=attr.validators.is_callable(),
+        default=get_default_async_client,
+        init=False,
+    )
+
+    def __hash__(self) -> int:
+        """Hash the class using its ID that caching works."""
+        return id(self)
+
+    @cache_result
+    @async_handle_receiver_exceptions
+    async def async_get(
+        self,
+        url: str,
+        timeout: float,
+        read_timeout: float,
+        *,
+        cache_id: Hashable = None,
+    ) -> httpx.Response:
+        """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()
+        finally:
+            # Close the default AsyncClient but keep custom clients open
+            if self.is_default_async_client():
+                await client.aclose()
+
+        return res
+
+    @cache_result
+    @async_handle_receiver_exceptions
+    async def async_post(
+        self,
+        url: str,
+        timeout: float,
+        read_timeout: float,
+        *,
+        content: Optional[bytes] = None,
+        data: Optional[Dict] = None,
+        cache_id: Hashable = None,
+    ) -> httpx.Response:
+        """Call GET endpoint of Denon AVR receiver asynchronously."""
+        client = self.client_getter()
+        try:
+            res = await client.post(
+                url,
+                content=content,
+                data=data,
+                timeout=httpx.Timeout(timeout, read=read_timeout),
+            )
+            res.raise_for_status()
+        finally:
+            # Close the default AsyncClient but keep custom clients open
+            if self.is_default_async_client():
+                await client.aclose()
+
+        return res
+
+    def is_default_async_client(self) -> bool:
+        """Check if default httpx.AsyncClient getter is used."""
+        return self.client_getter is get_default_async_client
+
+
+@attr.s(auto_attribs=True, on_setattr=DENON_ATTR_SETATTR)
 class DenonAVRApi:
     """Perform API calls to Denon AVR REST interface."""
 
     host: str = attr.ib(converter=str, default="localhost")
     port: int = attr.ib(converter=int, default=80)
-    timeout: httpx.Timeout = attr.ib(
-        validator=attr.validators.instance_of(httpx.Timeout),
-        default=httpx.Timeout(2.0, read=15.0),
-    )
+    timeout: float = attr.ib(converter=float, default=2.0)
+    read_timeout: float = attr.ib(converter=float, default=15.0)
     _appcommand_update_tags: Tuple[AppCommandCmd] = attr.ib(
         validator=attr.validators.deep_iterable(
             attr.validators.instance_of(AppCommandCmd),
@@ -107,23 +178,18 @@ class DenonAVRApi:
         ),
         default=attr.Factory(tuple),
     )
-    async_client_getter: Callable[[], httpx.AsyncClient] = attr.ib(
-        validator=attr.validators.is_callable(),
-        default=get_default_async_client,
+    httpx_async_client: HTTPXAsyncClient = attr.ib(
+        validator=attr.validators.instance_of(HTTPXAsyncClient),
+        default=attr.Factory(HTTPXAsyncClient),
         init=False,
     )
 
-    def __hash__(self) -> int:
-        """
-        Hash the class in a custom way that caching works.
-
-        It should react on changes of host and port.
-        """
-        return hash((self.host, self.port))
-
-    @async_handle_receiver_exceptions
     async def async_get(
-        self, request: str, port: Optional[int] = None
+        self,
+        request: str,
+        *,
+        port: Optional[int] = None,
+        cache_id: Hashable = None,
     ) -> httpx.Response:
         """Call GET endpoint of Denon AVR receiver asynchronously."""
         # Use default port of the receiver if no different port is specified
@@ -131,24 +197,18 @@ class DenonAVRApi:
 
         endpoint = f"http://{self.host}:{port}{request}"
 
-        client = self.async_client_getter()
-        try:
-            res = await client.get(endpoint, timeout=self.timeout)
-            res.raise_for_status()
-        finally:
-            # Close the default AsyncClient but keep custom clients open
-            if self.is_default_async_client():
-                await client.aclose()
-
-        return res
+        return await self.httpx_async_client.async_get(
+            endpoint, self.timeout, self.read_timeout, cache_id=cache_id
+        )
 
-    @async_handle_receiver_exceptions
     async def async_post(
         self,
         request: str,
+        *,
         content: Optional[bytes] = None,
         data: Optional[Dict] = None,
         port: Optional[int] = None,
+        cache_id: Hashable = None,
     ) -> httpx.Response:
         """Call POST endpoint of Denon AVR receiver asynchronously."""
         # Use default port of the receiver if no different port is specified
@@ -156,20 +216,15 @@ class DenonAVRApi:
 
         endpoint = f"http://{self.host}:{port}{request}"
 
-        client = self.async_client_getter()
-        try:
-            res = await client.post(
-                endpoint, content=content, data=data, timeout=self.timeout
-            )
-            res.raise_for_status()
-        finally:
-            # Close the default AsyncClient but keep custom clients open
-            if self.is_default_async_client():
-                await client.aclose()
-
-        return res
+        return await self.httpx_async_client.async_post(
+            endpoint,
+            self.timeout,
+            self.read_timeout,
+            content=content,
+            data=data,
+            cache_id=cache_id,
+        )
 
-    @async_handle_receiver_exceptions
     async def async_get_command(self, request: str) -> str:
         """Send HTTP GET command to Denon AVR receiver asynchronously."""
         # HTTP GET to endpoint
@@ -177,34 +232,46 @@ class DenonAVRApi:
         # Return text
         return res.text
 
-    @cache_result
-    @async_handle_receiver_exceptions
     async def async_get_xml(
-        self, request: str, cache_id: Hashable = None
+        self, request: str, *, cache_id: Hashable = None
     ) -> ET.Element:
         """Return XML data from HTTP GET endpoint asynchronously."""
         # HTTP GET to endpoint
-        res = await self.async_get(request)
+        res = await self.async_get(request, cache_id=cache_id)
         # create ElementTree
-        xml_root = fromstring(res.text)
+        try:
+            xml_root = fromstring(res.text)
+        except (
+            ET.ParseError,
+            DefusedXmlException,
+            ParseError,
+            UnicodeDecodeError,
+        ) as err:
+            raise AvrInvalidResponseError(f"XMLParseError: {err}", request) from err
         # Check validity of XML
         self.check_xml_validity(request, xml_root)
         # Return ElementTree element
         return xml_root
 
-    @cache_result
-    @async_handle_receiver_exceptions
     async def async_post_appcommand(
-        self, request: str, cmds: Tuple[AppCommandCmd], cache_id: Hashable = None
+        self, request: str, cmds: Tuple[AppCommandCmd], *, cache_id: Hashable = None
     ) -> ET.Element:
         """Return XML from Appcommand(0300) endpoint asynchronously."""
         # Prepare XML body for POST call
         content = self.prepare_appcommand_body(cmds)
         _LOGGER.debug("Content for %s endpoint: %s", request, content)
         # HTTP POST to endpoint
-        res = await self.async_post(request, content=content)
+        res = await self.async_post(request, content=content, cache_id=cache_id)
         # create ElementTree
-        xml_root = fromstring(res.text)
+        try:
+            xml_root = fromstring(res.text)
+        except (
+            ET.ParseError,
+            DefusedXmlException,
+            ParseError,
+            UnicodeDecodeError,
+        ) as err:
+            raise AvrInvalidResponseError(f"XMLParseError: {err}", request) from err
         # Check validity of XML
         self.check_xml_validity(request, xml_root)
         # Add query tags to result
@@ -350,10 +417,6 @@ class DenonAVRApi:
 
         return body_bytes
 
-    def is_default_async_client(self) -> bool:
-        """Check if default httpx.AsyncClient getter is used."""
-        return self.async_client_getter is get_default_async_client
-
 
 class DenonAVRTelnetProtocol(asyncio.Protocol):
     """Protocol for the Denon AVR Telnet interface."""
@@ -401,9 +464,9 @@ class DenonAVRTelnetProtocol(asyncio.Protocol):
 
     def connection_lost(self, exc: Optional[Exception]) -> None:
         """Handle connection lost."""
-        self.transport = None
         self._on_connection_lost()
-        return super().connection_lost(exc)
+        super().connection_lost(exc)
+        self.transport = None
 
 
 @attr.s(auto_attribs=True, hash=False, on_setattr=DENON_ATTR_SETATTR)
@@ -413,9 +476,6 @@ class DenonAVRTelnetApi:
     host: str = attr.ib(converter=str, default="localhost")
     timeout: float = attr.ib(converter=float, default=2.0)
     _connection_enabled: bool = attr.ib(default=False)
-    _healthy: Optional[bool] = attr.ib(
-        converter=attr.converters.optional(bool), default=None
-    )
     _last_message_time: float = attr.ib(default=-1.0)
     _connect_lock: asyncio.Lock = attr.ib(default=attr.Factory(asyncio.Lock))
     _reconnect_task: asyncio.Task = attr.ib(default=None)
@@ -474,18 +534,18 @@ class DenonAVRTelnetApi:
             raise AvrTimoutError(f"TimeoutException: {err}", "telnet connect") from err
         except ConnectionRefusedError as err:
             _LOGGER.debug(
-                "%s: Connection refused on telnet connect", self.host, exc_info=True
+                "%s: Connection refused on telnet connect: %s", self.host, err
             )
             raise AvrNetworkError(
                 f"ConnectionRefusedError: {err}", "telnet connect"
             ) from err
         except (OSError, IOError) as err:
             _LOGGER.debug(
-                "%s: Connection failed on telnet reconnect", self.host, exc_info=True
+                "%s: Connection failed on telnet reconnect: %s", self.host, err
             )
             raise AvrNetworkError(f"OSError: {err}", "telnet connect") from err
-        _LOGGER.debug("%s: telnet connection complete", self.host)
         self._protocol = cast(DenonAVRTelnetProtocol, transport_protocol[1])
+        _LOGGER.debug("%s: telnet connection established", self.host)
         self._connection_enabled = True
         self._last_message_time = time.monotonic()
         self._schedule_monitor()
@@ -507,6 +567,7 @@ class DenonAVRTelnetApi:
             "PSREFLEV ?",
             "PSDYNVOL ?",
             "MS?",
+            skip_confirmation=True,
         )
 
     def _schedule_monitor(self) -> None:
@@ -527,8 +588,6 @@ class DenonAVRTelnetApi:
             _LOGGER.info(
                 "%s: Keep alive failed, disconnecting and reconnecting", self.host
             )
-            if self._protocol is not None:
-                self._protocol.close()
             self._handle_disconnected()
             return
 
@@ -540,16 +599,20 @@ class DenonAVRTelnetApi:
 
     def _handle_disconnected(self) -> None:
         """Handle disconnected."""
-        _LOGGER.debug("%s: disconnected", self.host)
-        self._protocol = None
+        _LOGGER.debug("%s: handle disconnected", self.host)
+        if self._protocol is not None:
+            self._protocol.close()
+            self._protocol = None
         self._stop_monitor()
         if not self._connection_enabled:
             return
-        self._reconnect_task = asyncio.create_task(self._async_reconnect())
+        if self._reconnect_task is None:
+            self._reconnect_task = asyncio.create_task(self._async_reconnect())
 
     async def async_disconnect(self) -> None:
         """Close the connection to the receiver asynchronously."""
         async with self._connect_lock:
+            _LOGGER.debug("%s: telnet disconnecting", self.host)
             self._connection_enabled = False
             self._stop_monitor()
             reconnect_task = self._reconnect_task
@@ -565,6 +628,7 @@ class DenonAVRTelnetApi:
                     await reconnect_task
                 except asyncio.CancelledError:
                     pass
+            _LOGGER.debug("%s: telnet disconnected", self.host)
 
     async def _async_reconnect(self) -> None:
         """Reconnect to the receiver asynchronously."""
@@ -572,27 +636,36 @@ class DenonAVRTelnetApi:
 
         while self._connection_enabled and not self.healthy:
             async with self._connect_lock:
+                _LOGGER.debug("%s: Telnet reconnecting", self.host)
                 try:
                     await self._async_establish_connection()
                 except AvrTimoutError:
                     _LOGGER.debug(
                         "%s: Timeout exception on telnet reconnect", self.host
                     )
-                except AvrNetworkError as ex:
-                    _LOGGER.debug("%s: %s", self.host, ex, exc_info=True)
-                except Exception:  # pylint: disable=broad-except
+                except AvrNetworkError as err:
+                    _LOGGER.debug("%s: %s", self.host, err)
+                except AvrProcessingError as err:
+                    _LOGGER.debug(
+                        "%s: Failed updating state on telnet reconnect: %s",
+                        self.host,
+                        err,
+                    )
+                except Exception as err:  # pylint: disable=broad-except
                     _LOGGER.error(
                         "%s: Unexpected exception on telnet reconnect",
                         self.host,
-                        exc_info=True,
+                        exc_info=err,
                     )
                 else:
                     _LOGGER.info("%s: Telnet reconnected", self.host)
-                    return
+                    break
 
             await asyncio.sleep(backoff)
             backoff = min(30.0, backoff * 2)
 
+        self._reconnect_task = None
+
     def register_callback(
         self, event: str, callback: Callable[[str, str, str], Awaitable[None]]
     ) -> None:
@@ -603,6 +676,8 @@ class DenonAVRTelnetApi:
 
         if event not in self._callbacks.keys():
             self._callbacks[event] = []
+        elif callback in self._callbacks[event]:
+            return
         self._callbacks[event].append(callback)
 
     def unregister_callback(
@@ -617,6 +692,8 @@ class DenonAVRTelnetApi:
         self, callback: Callable[[str], Awaitable[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(
@@ -682,7 +759,7 @@ class DenonAVRTelnetApi:
                 # We don't want a single bad callback to trip up the
                 # whole system and prevent further execution
                 _LOGGER.error(
-                    "%s: Raw callback caused an unhandled exception %s",
+                    "%s: Raw callback caused an unhandled exception: %s",
                     self.host,
                     err,
                 )
@@ -695,7 +772,7 @@ class DenonAVRTelnetApi:
                     # We don't want a single bad callback to trip up the
                     # whole system and prevent further execution
                     _LOGGER.error(
-                        "%s: Event callback caused an unhandled exception %s",
+                        "%s: Event callback caused an unhandled exception: %s",
                         self.host,
                         err,
                     )
@@ -708,7 +785,7 @@ class DenonAVRTelnetApi:
                     # We don't want a single bad callback to trip up the
                     # whole system and prevent further execution
                     _LOGGER.error(
-                        "%s: Event callback caused an unhandled exception %s",
+                        "%s: Event callback caused an unhandled exception: %s",
                         self.host,
                         err,
                     )
@@ -731,35 +808,45 @@ class DenonAVRTelnetApi:
             self._send_confirmation_event.set()
             _LOGGER.debug("Command %s confirmed", command)
 
-    async def _async_send_command(self, command: str) -> None:
+    async def _async_send_command(
+        self, command: str, skip_confirmation: bool = False
+    ) -> None:
         """Send one telnet command to the receiver."""
         async with self._send_lock:
-            self._send_confirmation_command = command
-            self._send_confirmation_event.clear()
+            if not skip_confirmation:
+                self._send_confirmation_command = command
+                self._send_confirmation_event.clear()
             if not self.connected or not self.healthy:
                 raise AvrProcessingError(
                     f"Error sending command {command}. Telnet connected: "
                     f"{self.connected}, Connection healthy: {self.healthy}"
                 )
             self._protocol.write(f"{command}\r")
-            try:
-                await asyncio.wait_for(
-                    self._send_confirmation_event.wait(),
-                    self._send_confirmation_timeout,
-                )
-            except asyncio.TimeoutError:
-                _LOGGER.info("Timeout waiting for confirmation of command: %s", command)
-            finally:
-                self._send_confirmation_command = ""
+            if not skip_confirmation:
+                try:
+                    await asyncio.wait_for(
+                        self._send_confirmation_event.wait(),
+                        self._send_confirmation_timeout,
+                    )
+                except asyncio.TimeoutError:
+                    _LOGGER.info(
+                        "Timeout waiting for confirmation of command: %s", command
+                    )
+                finally:
+                    self._send_confirmation_command = ""
 
-    async def async_send_commands(self, *commands: str) -> None:
+    async def async_send_commands(
+        self, *commands: str, skip_confirmation: bool = False
+    ) -> None:
         """Send telnet commands to the receiver."""
         for command in commands:
-            await self._async_send_command(command)
+            await self._async_send_command(command, skip_confirmation=skip_confirmation)
 
-    def send_commands(self, *commands: str) -> None:
+    def send_commands(self, *commands: str, skip_confirmation: bool = False) -> None:
         """Send telnet commands to the receiver."""
-        task = asyncio.create_task(self.async_send_commands(*commands))
+        task = asyncio.create_task(
+            self.async_send_commands(*commands, skip_confirmation=skip_confirmation)
+        )
         self._send_tasks.add(task)
         task.add_done_callback(self._send_tasks.discard)
 

denonavr/audyssey.py

@@ -99,12 +99,14 @@ class DenonAVRAudyssey(DenonAVRFoundation):
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
         """Update Audyssey asynchronously."""
+        _LOGGER.debug("Starting Audyssey update")
         # Ensure instance is setup before updating
         if not self._is_setup:
             self.setup()
 
         # Update state
         await self.async_update_audyssey(global_update=global_update, cache_id=cache_id)
+        _LOGGER.debug("Finished Audyssey update")
 
     async def async_update_audyssey(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
@@ -117,13 +119,16 @@ class DenonAVRAudyssey(DenonAVRFoundation):
 
         # Audyssey is only available for avr 2016 update
         if self._device.use_avr_2016_update:
-            await self.async_update_attrs_appcommand(
-                self.appcommand0300_attrs,
-                appcommand0300=True,
-                global_update=global_update,
-                cache_id=cache_id,
-                ignore_missing_response=True,
-            )
+            try:
+                await self.async_update_attrs_appcommand(
+                    self.appcommand0300_attrs,
+                    appcommand0300=True,
+                    global_update=global_update,
+                    cache_id=cache_id,
+                )
+            except AvrProcessingError as err:
+                # Don't raise an error here, because not all devices support it
+                _LOGGER.debug("Updating Audyssey failed: %s", err)
 
     async def _async_set_audyssey(self, cmd: AppCommandCmd) -> None:
         """Set Audyssey parameter."""