denonavr 0.11.5__tar.gz → 1.0.0__tar.gz

denonavr-1.0.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.1
+Name: denonavr
+Version: 1.0.0
+Summary: Automation Library for Denon AVR receivers
+Author-email: Oliver Goetz <scarface@mywoh.de>
+License: MIT
+Project-URL: Homepage, https://github.com/ol-iver/denonavr
+Project-URL: Source, https://github.com/ol-iver/denonavr
+Project-URL: Tracker, https://github.com/ol-iver/denonavr/issues
+Platform: any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Home Automation
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown; charset=UTF-8
+License-File: LICENSE
+Requires-Dist: asyncstdlib>=3.10.2
+Requires-Dist: attrs>=21.2.0
+Requires-Dist: defusedxml>=0.7.1
+Requires-Dist: ftfy>=6.1.1
+Requires-Dist: httpx>=0.23.1
+Requires-Dist: netifaces>=0.11.0
+Requires-Dist: async-timeout>=4.0.2; python_version < "3.11"
+Provides-Extra: testing
+Requires-Dist: pydocstyle; extra == "testing"
+Requires-Dist: pylint; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-timeout; extra == "testing"
+Requires-Dist: pytest-asyncio; extra == "testing"
+Requires-Dist: pytest-httpx; extra == "testing"
+Requires-Dist: flake8-docstrings; extra == "testing"
+Requires-Dist: flake8; extra == "testing"
+
+# denonavr
+[![Release](https://img.shields.io/github/v/release/ol-iver/denonavr?sort=semver)](https://github.com/ol-iver/denonavr/releases/latest)
+[![Build Status](https://github.com/ol-iver/denonavr/actions/workflows/python-tests.yml/badge.svg)](https://github.com/ol-iver/denonavr/actions/workflows/python-tests.yml)
+[![PyPi](https://img.shields.io/pypi/v/denonavr.svg)](https://pypi.org/project/denonavr)
+[![License](https://img.shields.io/github/license/ol-iver/denonavr.svg)](LICENSE)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+Automation Library for Denon AVR receivers
+
+## Installation
+
+Use pip:
+
+```$ pip install denonavr```
+
+or 
+
+```$ pip install --use-wheel denonavr```
+  
+## Usage with `async`
+
+Writing `async` and `await` methods are outside the scope of the documentation.  You can test `async` usage from the Python REPL.  In a terminal run:
+
+`python3 -m asyncio`
+
+The `asyncio` library should automatically be imported in the REPL.  Import the `denonavr` library and set up your receiver.  If you know the  IP address, enter it below replacing `192.168.1.119`.
+
+```
+>>> import asyncio
+>>> import denonavr
+>>> d = denonavr.DenonAVR("192.168.1.119")
+>>> await d.async_setup()
+>>> await d.async_update()
+>>> print(d.volume)
+-36.5
+```
+
+### Monitoring with telnet
+In addition to retrieving the current device status via HTTP calls, `denonavr` library also has the ability to setup a task that will connect to the receiver via telnet on TCP port 23 and listen for real-time events to notify of status changes.
+This provides instant updates via a callback when the device status changes. Receivers support only one active telnet connection.
+
+```
+>>> import asyncio
+>>> import denonavr
+>>> d = denonavr.DenonAVR("192.168.1.119")
+>>> await d.async_setup()
+>>> await d.async_telnet_connect()
+>>> await d.async_update()
+>>> async def update_callback(zone, event, parameter):
+>>>>>> print("Zone: " + zone + " Event: " + event + " Parameter: " + parameter)
+>>> d.register_callback("ALL", update_callback)
+```
+
+### Power & Input
+```
+>>> await d.async_power_on()
+>>> await d.async_update()
+>>> d.power
+'ON'
+
+>>> await d.async_power_off()
+>>> await d.async_update()
+>>> d.power
+'OFF'
+
+>>> d.input_func
+'Tuner'
+>>> await d.async_set_input_func("Phono")
+>>> d.input_func
+'Phono'
+```
+### Sound
+```
+>>> await d.async_mute(True)
+>>> await d.async_mute(False)
+```
+
+### Other methods
+
+Other `async` methods available include:
+
+* `d.async_bass_down`
+* `d.async_bass_up`
+* `d.async_treble_down`
+* `d.async_treble_up`
+* `d.async_volume_down`
+* `d.async_volume_up`
+* `d.async_set_volume(50)`
+
+## Collection of HTTP calls
+For a collection of HTTP calls for Denon receivers please have a look at the `doc` folder.
+
+## License
+MIT
+
+## Author
+@ol-iver: https://github.com/ol-iver
+
+## Contributors
+@soldag: https://github.com/soldag  
+@shapiromatron: https://github.com/shapiromatron  
+@glance-: https://github.com/glance-  
+@p3dda: https://github.com/p3dda  
+@russel: https://github.com/russell  
+@starkillerOG: https://github.com/starkillerOG  
+@andrewsayre: https://github.com/andrewsayre  
+@JPHutchins: https://github.com/JPHutchins  
+@MarBra: https://github.com/MarBra  
+@dcmeglio: https://github.com/dcmeglio  
+@bdraco: https://github.com/bdraco  
+
+## Users
+Home Assistant: https://github.com/home-assistant/home-assistant/  
+denonavr-cli: https://pypi.org/project/denonavr-cli/

denonavr-1.0.0/README.md

@@ -0,0 +1,114 @@
+# denonavr
+[![Release](https://img.shields.io/github/v/release/ol-iver/denonavr?sort=semver)](https://github.com/ol-iver/denonavr/releases/latest)
+[![Build Status](https://github.com/ol-iver/denonavr/actions/workflows/python-tests.yml/badge.svg)](https://github.com/ol-iver/denonavr/actions/workflows/python-tests.yml)
+[![PyPi](https://img.shields.io/pypi/v/denonavr.svg)](https://pypi.org/project/denonavr)
+[![License](https://img.shields.io/github/license/ol-iver/denonavr.svg)](LICENSE)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+Automation Library for Denon AVR receivers
+
+## Installation
+
+Use pip:
+
+```$ pip install denonavr```
+
+or 
+
+```$ pip install --use-wheel denonavr```
+  
+## Usage with `async`
+
+Writing `async` and `await` methods are outside the scope of the documentation.  You can test `async` usage from the Python REPL.  In a terminal run:
+
+`python3 -m asyncio`
+
+The `asyncio` library should automatically be imported in the REPL.  Import the `denonavr` library and set up your receiver.  If you know the  IP address, enter it below replacing `192.168.1.119`.
+
+```
+>>> import asyncio
+>>> import denonavr
+>>> d = denonavr.DenonAVR("192.168.1.119")
+>>> await d.async_setup()
+>>> await d.async_update()
+>>> print(d.volume)
+-36.5
+```
+
+### Monitoring with telnet
+In addition to retrieving the current device status via HTTP calls, `denonavr` library also has the ability to setup a task that will connect to the receiver via telnet on TCP port 23 and listen for real-time events to notify of status changes.
+This provides instant updates via a callback when the device status changes. Receivers support only one active telnet connection.
+
+```
+>>> import asyncio
+>>> import denonavr
+>>> d = denonavr.DenonAVR("192.168.1.119")
+>>> await d.async_setup()
+>>> await d.async_telnet_connect()
+>>> await d.async_update()
+>>> async def update_callback(zone, event, parameter):
+>>>>>> print("Zone: " + zone + " Event: " + event + " Parameter: " + parameter)
+>>> d.register_callback("ALL", update_callback)
+```
+
+### Power & Input
+```
+>>> await d.async_power_on()
+>>> await d.async_update()
+>>> d.power
+'ON'
+
+>>> await d.async_power_off()
+>>> await d.async_update()
+>>> d.power
+'OFF'
+
+>>> d.input_func
+'Tuner'
+>>> await d.async_set_input_func("Phono")
+>>> d.input_func
+'Phono'
+```
+### Sound
+```
+>>> await d.async_mute(True)
+>>> await d.async_mute(False)
+```
+
+### Other methods
+
+Other `async` methods available include:
+
+* `d.async_bass_down`
+* `d.async_bass_up`
+* `d.async_treble_down`
+* `d.async_treble_up`
+* `d.async_volume_down`
+* `d.async_volume_up`
+* `d.async_set_volume(50)`
+
+## Collection of HTTP calls
+For a collection of HTTP calls for Denon receivers please have a look at the `doc` folder.
+
+## License
+MIT
+
+## Author
+@ol-iver: https://github.com/ol-iver
+
+## Contributors
+@soldag: https://github.com/soldag  
+@shapiromatron: https://github.com/shapiromatron  
+@glance-: https://github.com/glance-  
+@p3dda: https://github.com/p3dda  
+@russel: https://github.com/russell  
+@starkillerOG: https://github.com/starkillerOG  
+@andrewsayre: https://github.com/andrewsayre  
+@JPHutchins: https://github.com/JPHutchins  
+@MarBra: https://github.com/MarBra  
+@dcmeglio: https://github.com/dcmeglio  
+@bdraco: https://github.com/bdraco  
+
+## Users
+Home Assistant: https://github.com/home-assistant/home-assistant/  
+denonavr-cli: https://pypi.org/project/denonavr-cli/

{denonavr-0.11.5 → denonavr-1.0.0}/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.5"
+__version__ = "1.0.0"
 
 
 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-0.11.5 → denonavr-1.0.0}/denonavr/api.py

@@ -401,9 +401,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 +413,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,17 +471,17 @@ 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)
+        _LOGGER.debug("%s: telnet connection established", self.host)
         self._protocol = cast(DenonAVRTelnetProtocol, transport_protocol[1])
         self._connection_enabled = True
         self._last_message_time = time.monotonic()
@@ -507,6 +504,7 @@ class DenonAVRTelnetApi:
             "PSREFLEV ?",
             "PSDYNVOL ?",
             "MS?",
+            skip_confirmation=True,
         )
 
     def _schedule_monitor(self) -> None:
@@ -527,8 +525,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,8 +536,10 @@ 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
@@ -550,6 +548,7 @@ class DenonAVRTelnetApi:
     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 +564,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,19 +572,20 @@ 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 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)
@@ -682,7 +683,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 +696,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 +709,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 +732,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-0.11.5 → denonavr-1.0.0}/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."""