denonavr 1.0.0__py3-none-any.whl → 1.1.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.0.0"
+__version__ = "1.1.0"
 
 
 async def async_discover():

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."""
@@ -481,8 +544,8 @@ class DenonAVRTelnetApi:
                 "%s: Connection failed on telnet reconnect: %s", self.host, err
             )
             raise AvrNetworkError(f"OSError: {err}", "telnet connect") from err
-        _LOGGER.debug("%s: telnet connection established", 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()
@@ -500,10 +563,55 @@ class DenonAVRTelnetApi:
             "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,
         )
 
@@ -543,7 +651,8 @@ class DenonAVRTelnetApi:
         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."""
@@ -581,6 +690,12 @@ class DenonAVRTelnetApi:
                     )
                 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",
@@ -589,11 +704,13 @@ class DenonAVRTelnetApi:
                     )
                 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:
@@ -604,6 +721,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(
@@ -618,6 +737,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(

denonavr/audyssey.py

@@ -60,6 +60,12 @@ class DenonAVRAudyssey(DenonAVRFoundation):
     _multeq_control: Optional[bool] = attr.ib(
         converter=attr.converters.optional(convert_string_int_bool), default=None
     )
+    _lfc: Optional[bool] = attr.ib(
+        converter=attr.converters.optional(convert_string_int_bool), default=None
+    )
+    _containment_amount: Optional[int] = attr.ib(
+        converter=attr.converters.optional(int), default=None
+    )
 
     # Update tags for attributes
     # AppCommand0300.xml interface
@@ -94,6 +100,12 @@ class DenonAVRAudyssey(DenonAVRFoundation):
             self._dynamiceq = "1"
         elif parameter == "DYNEQ OFF":
             self._dynamiceq = "0"
+        elif parameter == "LFC ON":
+            self._lfc = "1"
+        elif parameter == "LFC OFF":
+            self._lfc = "0"
+        elif parameter[:6] == "CNTAMT":
+            self._containment_amount = int(parameter[7:])
 
     async def async_update(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
@@ -186,6 +198,24 @@ class DenonAVRAudyssey(DenonAVRFoundation):
             return list(MULTI_EQ_MAP_LABELS_TELNET.keys())
         return list(MULTI_EQ_MAP_LABELS_APPCOMMAND.keys())
 
+    @property
+    def lfc(self) -> Optional[bool]:
+        """
+        Return value of LFC.
+
+        Only available if using Telnet.
+        """
+        return self._lfc
+
+    @property
+    def containment_amount(self) -> Optional[int]:
+        """
+        Return value of Containment Amount.
+
+        Only available if using Telnet.
+        """
+        return self._containment_amount
+
     ##########
     # Setter #
     ##########
@@ -284,6 +314,81 @@ class DenonAVRAudyssey(DenonAVRFoundation):
         else:
             await self.async_dynamiceq_on()
 
+    async def async_lfc_on(self):
+        """Turn LFC on."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_lfc.format(mode="ON")
+            )
+            return
+        await self._device.api.async_get_command(
+            self._device.urls.command_lfc.format(mode="ON")
+        )
+
+    async def async_lfc_off(self):
+        """Turn LFC off."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_lfc.format(mode="OFF")
+            )
+            return
+        await self._device.api.async_get_command(
+            self._device.urls.command_lfc.format(mode="OFF")
+        )
+
+    async def async_toggle_lfc(self):
+        """Toggle LFC."""
+        if self._lfc:
+            await self.async_lfc_off()
+        else:
+            await self.async_lfc_on()
+
+    async def async_containment_amount(self, amount: int) -> None:
+        """
+        Set Containment Amount.
+
+        Valid values are 1-7.
+        """
+        if amount < 1 or amount > 7:
+            raise AvrCommandError("Containment amount must be between 1 and 7")
+        local_amount = f"{amount:02}"
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_containment_amount.format(
+                    value=local_amount
+                )
+            )
+            return
+        await self._device.api.async_get_command(
+            self._device.urls.command_containment_amount.format(value=local_amount)
+        )
+
+    async def async_containment_amount_up(self) -> None:
+        """Increase Containment Amount."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_containment_amount.format(
+                    value="UP"
+                )
+            )
+            return
+        await self._device.api.async_get_command(
+            self._device.urls.command_containment_amount.format(value="UP")
+        )
+
+    async def async_containment_amount_down(self) -> None:
+        """Decrease Containment Amount."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_containment_amount.format(
+                    value="DOWN"
+                )
+            )
+            return
+        await self._device.api.async_get_command(
+            self._device.urls.command_containment_amount.format(value="DOWN")
+        )
+
 
 def audyssey_factory(instance: DenonAVRFoundation) -> DenonAVRAudyssey:
     """Create  DenonAVRAudyssey at receiver instances."""