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

denonavr/volume.py

@@ -9,14 +9,26 @@ This module implements the handler for volume of Denon AVR receivers.
 
 import logging
 from collections.abc import Hashable
-from typing import Optional, Union
+from typing import Dict, Optional, Union, get_args
 
 import attr
 
 from .appcommand import AppCommands
-from .const import DENON_ATTR_SETATTR, MAIN_ZONE, STATE_ON
+from .const import (
+    CHANNEL_MAP,
+    CHANNEL_MAP_LABELS,
+    CHANNEL_VOLUME_MAP,
+    CHANNEL_VOLUME_MAP_LABELS,
+    DENON_ATTR_SETATTR,
+    MAIN_ZONE,
+    STATE_ON,
+    SUBWOOFERS_MAP,
+    SUBWOOFERS_MAP_LABELS,
+    Channels,
+    Subwoofers,
+)
 from .exceptions import AvrCommandError, AvrProcessingError
-from .foundation import DenonAVRFoundation
+from .foundation import DenonAVRFoundation, convert_on_off_bool
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -43,7 +55,18 @@ class DenonAVRVolume(DenonAVRFoundation):
     _muted: Optional[bool] = attr.ib(
         converter=attr.converters.optional(convert_muted), default=None
     )
-
+    _channel_volumes: Optional[Dict[Channels, float]] = attr.ib(default=None)
+    _valid_channels = get_args(Channels)
+    _subwoofer: Optional[bool] = attr.ib(
+        converter=attr.converters.optional(convert_on_off_bool), default=None
+    )
+    _subwoofer_levels_adjustment: bool = attr.ib(default=True)
+    _subwoofer_levels: Optional[Dict[Subwoofers, float]] = attr.ib(default=None)
+    _valid_subwoofers = get_args(Subwoofers)
+    _lfe: Optional[int] = attr.ib(converter=attr.converters.optional(int), default=None)
+    _bass_sync: Optional[int] = attr.ib(
+        converter=attr.converters.optional(int), default=None
+    )
     # Update tags for attributes
     # AppCommand.xml interface
     appcommand_attrs = {
@@ -61,6 +84,17 @@ class DenonAVRVolume(DenonAVRFoundation):
 
         self._device.telnet_api.register_callback("MV", self._async_volume_callback)
         self._device.telnet_api.register_callback("MU", self._async_mute_callback)
+        self._device.telnet_api.register_callback(
+            "CV", self._async_channel_volume_callback
+        )
+        self._device.telnet_api.register_callback(
+            "PS", self._async_subwoofer_state_callback
+        )
+        self._device.telnet_api.register_callback(
+            "PS", self._async_subwoofer_levels_callback
+        )
+        self._device.telnet_api.register_callback("PS", self._async_lfe_callback)
+        self._device.telnet_api.register_callback("PS", self._async_bass_sync_callback)
 
         self._is_setup = True
 
@@ -85,6 +119,76 @@ class DenonAVRVolume(DenonAVRFoundation):
 
         self._muted = parameter
 
+    async def _async_channel_volume_callback(
+        self, zone: str, event: str, parameter: str
+    ) -> None:
+        """Handle a channel volume change event."""
+        if event != "CV":
+            return
+
+        channel_volume = parameter.split()
+        if (
+            len(channel_volume) != 2
+            or channel_volume[0] not in CHANNEL_MAP_LABELS
+            or channel_volume[1] not in CHANNEL_VOLUME_MAP
+        ):
+            return
+
+        if self._channel_volumes is None:
+            self._channel_volumes = {}
+
+        channel = CHANNEL_MAP_LABELS[channel_volume[0]]
+        volume = channel_volume[1]
+        self._channel_volumes[channel] = CHANNEL_VOLUME_MAP[volume]
+
+    async def _async_subwoofer_state_callback(
+        self, zone: str, event: str, parameter: str
+    ) -> None:
+        """Handle a subwoofer state change event."""
+        if parameter[:3] == "SWR":
+            self._subwoofer = parameter[4:]
+
+    async def _async_subwoofer_levels_callback(
+        self, zone: str, event: str, parameter: str
+    ) -> None:
+        """Handle a subwoofer levels change event."""
+        if parameter[:3] != "SWL":
+            return
+
+        subwoofer_volume = parameter.split()
+        if (
+            len(subwoofer_volume) != 2
+            or subwoofer_volume[0] not in SUBWOOFERS_MAP_LABELS
+        ):
+            return
+
+        if self._subwoofer_levels is None:
+            self._subwoofer_levels = {}
+
+        subwoofer = SUBWOOFERS_MAP_LABELS[subwoofer_volume[0]]
+        level = subwoofer_volume[1]
+        val = convert_on_off_bool(level)
+        if val is not None:
+            self._subwoofer_levels_adjustment = val
+        elif level in CHANNEL_VOLUME_MAP:
+            self._subwoofer_levels[subwoofer] = CHANNEL_VOLUME_MAP[level]
+
+    async def _async_lfe_callback(self, zone: str, event: str, parameter: str) -> None:
+        """Handle a LFE change event."""
+        if parameter[:3] != "LFE":
+            return
+
+        self._lfe = int(parameter[4:]) * -1
+
+    async def _async_bass_sync_callback(
+        self, zone: str, event: str, parameter: str
+    ) -> None:
+        """Handle a LFE change event."""
+        if parameter[:3] != "BSC":
+            return
+
+        self._bass_sync = int(parameter[4:]) * -1
+
     async def async_update(
         self, global_update: bool = False, cache_id: Optional[Hashable] = None
     ) -> None:
@@ -141,6 +245,79 @@ class DenonAVRVolume(DenonAVRFoundation):
         """
         return self._volume
 
+    @property
+    def channel_volumes(self) -> Optional[Dict[Channels, float]]:
+        """
+        Return the channel levels of the device in dB.
+
+        Only available if using Telnet.
+        """
+        return self._channel_volumes
+
+    @property
+    def subwoofer(self) -> Optional[bool]:
+        """
+        Return the state of the subwoofer.
+
+        Only available if using Telnet.
+        """
+        return self._subwoofer
+
+    @property
+    def subwoofer_levels(self) -> Optional[Dict[Subwoofers, Union[bool, float]]]:
+        """
+        Return the subwoofer levels of the device in dB when enabled.
+
+        Only available if using Telnet.
+        """
+        if self._subwoofer_levels_adjustment:
+            return self._subwoofer_levels
+
+        return None
+
+    @property
+    def lfe(self) -> Optional[int]:
+        """
+        Return LFE level in dB.
+
+        Only available if using Telnet.
+        """
+        return self._lfe
+
+    @property
+    def bass_sync(self) -> Optional[int]:
+        """
+        Return Bass Sync level in dB.
+
+        Only available if using Telnet.
+        """
+        return self._bass_sync
+
+    ##########
+    # Getter #
+    ##########
+    def channel_volume(self, channel: Channels) -> Optional[float]:
+        """
+        Return the volume of a channel in dB.
+
+        Only available if using Telnet.
+        """
+        self._is_valid_channel(channel)
+        if self._channel_volumes is None:
+            return None
+        return self._channel_volumes[channel]
+
+    def subwoofer_level(self, subwoofer: Subwoofers) -> Optional[float]:
+        """
+        Return the volume of a subwoofer in dB.
+
+        Only available if using Telnet.
+        """
+        self._is_valid_subwoofer(subwoofer)
+        if self._subwoofer_levels is None:
+            return None
+        return self._subwoofer_levels[subwoofer]
+
     ##########
     # Setter #
     ##########
@@ -210,6 +387,240 @@ class DenonAVRVolume(DenonAVRFoundation):
                     self._device.urls.command_mute_off
                 )
 
+    async def async_channel_volume_up(self, channel: Channels) -> None:
+        """Increase Channel volume on receiver via HTTP get command."""
+        self._is_valid_channel(channel)
+
+        mapped_channel = CHANNEL_MAP[channel]
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_channel_volume.format(
+                    channel=mapped_channel, value="UP"
+                )
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_channel_volume.format(
+                    channel=mapped_channel, value="UP"
+                )
+            )
+
+    async def async_channel_volume_down(self, channel: Channels) -> None:
+        """Decrease Channel volume on receiver via HTTP get command."""
+        self._is_valid_channel(channel)
+
+        mapped_channel = CHANNEL_MAP[channel]
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_channel_volume.format(
+                    channel=mapped_channel, value="DOWN"
+                )
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_channel_volume.format(
+                    channel=mapped_channel, value="DOWN"
+                )
+            )
+
+    async def async_channel_volume(self, channel: Channels, volume: float) -> None:
+        """
+        Set Channel volume on receiver via HTTP get command.
+
+        :param channel: Channel to set.
+        :param volume: Volume to set. Valid values are -12 to 12 with 0.5 steps.
+        """
+        self._is_valid_channel(channel)
+        if volume not in CHANNEL_VOLUME_MAP_LABELS:
+            raise AvrCommandError(f"Invalid channel volume: {volume}")
+
+        mapped_channel = CHANNEL_MAP[channel]
+        mapped_volume = CHANNEL_VOLUME_MAP_LABELS[volume]
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_channel_volume.format(
+                    channel=mapped_channel, value=mapped_volume
+                )
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_channel_volume.format(
+                    channel=mapped_channel, value=mapped_volume
+                )
+            )
+
+    async def async_channel_volumes_reset(self) -> None:
+        """Reset all channel volumes on receiver via HTTP get command."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_channel_volumes_reset
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_channel_volumes_reset
+            )
+
+    async def async_subwoofer_on(self) -> None:
+        """Turn on Subwoofer on receiver via HTTP get command."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_subwoofer_on_off.format(mode="ON")
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_subwoofer_on_off.format(mode="ON")
+            )
+
+    async def async_subwoofer_off(self) -> None:
+        """Turn off Subwoofer on receiver via HTTP get command."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_subwoofer_on_off.format(mode="OFF")
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_subwoofer_on_off.format(mode="OFF")
+            )
+
+    async def async_subwoofer_toggle(self) -> None:
+        """
+        Toggle Subwoofer on receiver via HTTP get command.
+
+        Only available if using Telnet.
+        """
+        if self._subwoofer:
+            await self.async_subwoofer_off()
+        else:
+            await self.async_subwoofer_on()
+
+    async def async_subwoofer_level_up(self, subwoofer: Subwoofers) -> None:
+        """Increase Subwoofer level on receiver via HTTP get command."""
+        self._is_valid_subwoofer(subwoofer)
+        mapped_subwoofer = SUBWOOFERS_MAP[subwoofer]
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_subwoofer_level.format(
+                    number=mapped_subwoofer, mode="UP"
+                )
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_subwoofer_level.format(
+                    number=mapped_subwoofer, mode="UP"
+                )
+            )
+
+    async def async_subwoofer_level_down(self, subwoofer: Subwoofers) -> None:
+        """Decrease Subwoofer level on receiver via HTTP get command."""
+        self._is_valid_subwoofer(subwoofer)
+        mapped_subwoofer = SUBWOOFERS_MAP[subwoofer]
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_subwoofer_level.format(
+                    number=mapped_subwoofer, mode="DOWN"
+                )
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_subwoofer_level.format(
+                    number=mapped_subwoofer, mode="DOWN"
+                )
+            )
+
+    async def async_lfe_up(self) -> None:
+        """Increase LFE on receiver via HTTP get command."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_lfe.format(mode="UP")
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_lfe.format(mode="UP")
+            )
+
+    async def async_lfe_down(self) -> None:
+        """Decrease LFE on receiver via HTTP get command."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_lfe.format(mode="DOWN")
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_lfe.format(mode="DOWN")
+            )
+
+    async def async_lfe(self, lfe: int) -> None:
+        """
+        Set LFE level on receiver via HTTP get command.
+
+        :param lfe: LFE level to set. Valid values are -10 to 0.
+        """
+        if lfe < -10 or lfe > 0:
+            raise AvrCommandError(f"Invalid LFE: {lfe}")
+
+        lfe_local = str(lfe).replace("-", "").zfill(2)
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_lfe.format(mode=lfe_local)
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_lfe.format(mode=lfe_local)
+            )
+
+    async def async_bass_sync_up(self) -> None:
+        """Increase Bass Sync on receiver via HTTP get command."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_bass_sync.format(mode="UP")
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_bass_sync.format(mode="UP")
+            )
+
+    async def async_bass_sync_down(self) -> None:
+        """Decrease Bass Sync on receiver via HTTP get command."""
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_bass_sync.format(mode="DOWN")
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_bass_sync.format(mode="DOWN")
+            )
+
+    async def async_bass_sync(self, lfe: int) -> None:
+        """
+        Set Bass Sync level on receiver via HTTP get command.
+
+        :param lfe: Bass Sync level to set. Valid values are -10 to 0.
+        """
+        if lfe < -10 or lfe > 0:
+            raise AvrCommandError(f"Invalid Bass Sync: {lfe}")
+
+        bass_sync_local = str(lfe).replace("-", "").zfill(2)
+        if self._device.telnet_available:
+            await self._device.telnet_api.async_send_commands(
+                self._device.telnet_commands.command_bass_sync.format(
+                    mode=bass_sync_local
+                )
+            )
+        else:
+            await self._device.api.async_get_command(
+                self._device.urls.command_bass_sync.format(mode=bass_sync_local)
+            )
+
+    @staticmethod
+    def _is_valid_channel(channel: Channels):
+        if channel not in DenonAVRVolume._valid_channels:
+            raise AvrCommandError("Invalid channel")
+
+    @staticmethod
+    def _is_valid_subwoofer(subwoofer: Subwoofers):
+        if subwoofer not in DenonAVRVolume._valid_subwoofers:
+            raise AvrCommandError("Invalid subwoofer")
+
 
 def volume_factory(instance: DenonAVRFoundation) -> DenonAVRVolume:
     """Create DenonAVRVolume at receiver instances."""

{denonavr-1.0.1.dist-info → denonavr-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: denonavr
-Version: 1.0.1
+Version: 1.1.0
 Summary: Automation Library for Denon AVR receivers
 Author-email: Oliver Goetz <scarface@mywoh.de>
 License: MIT
@@ -14,14 +14,13 @@ 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
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown; charset=UTF-8
 License-File: LICENSE
 Requires-Dist: asyncstdlib>=3.10.2
@@ -41,6 +40,7 @@ Requires-Dist: pytest-asyncio; extra == "testing"
 Requires-Dist: pytest-httpx; extra == "testing"
 Requires-Dist: flake8-docstrings; extra == "testing"
 Requires-Dist: flake8; extra == "testing"
+Dynamic: license-file
 
 # denonavr
 [![Release](https://img.shields.io/github/v/release/ol-iver/denonavr?sort=semver)](https://github.com/ol-iver/denonavr/releases/latest)
@@ -132,27 +132,11 @@ Other `async` methods available include:
 * `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.
+For a collection of HTTP calls for Denon receivers please have a look at the [doc folder](doc/XML_data_dump.txt).
 
 ## 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.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+denonavr/__init__.py,sha256=LfB6oTshGAwfau1j3RXNNPFt3NTQeKbsZFVovFBhWWk,1325
+denonavr/api.py,sha256=SaJls_9yQ8TyklzWwflubwy6oJki1NYIQGeeHNf-3ss,32530
+denonavr/appcommand.py,sha256=H37VK4n-yW0ISvR1hfX8G4udQtGASoY44QNaXtLSidE,7784
+denonavr/audyssey.py,sha256=d7mSkRiMvrZMtCzQdixfJuLmkuZeSi1w1GgQ_1fm-j8,14655
+denonavr/const.py,sha256=HwdM3x-Fa3DxOs1-Tpg28Z9LSCRpMoI8-pSOhdmhx64,54261
+denonavr/decorators.py,sha256=tLoVjGtDmN75fhwCgNREMGjbB6varDERnYlrhC6yIZ8,2733
+denonavr/denonavr.py,sha256=lN_xwG9sa1TYCZQi24FRq4p4jV6GaOuDefYGuLvvXGI,39823
+denonavr/dirac.py,sha256=my8E9r-t8u579chnyIhJb1afNme73bQGCxj3D3TQX8g,2534
+denonavr/exceptions.py,sha256=naP7MCuNH98rv7y_lDdO7ayyvQGywnsfpHhW-o9tKeo,1725
+denonavr/foundation.py,sha256=1_fpV9pA0Jz36Rnieowz4myqpAdaCaNwP74QTdMpSgk,72785
+denonavr/input.py,sha256=kbKPePkdFHQSHKzOvAYudeSyJiRrUh0PxIOkG38kDUo,43050
+denonavr/soundmode.py,sha256=kO2lxaj_i8G31fmwH9tu66YIZ6XaYA-kuFBKxYJhsdE,44632
+denonavr/ssdp.py,sha256=4gyvN0yo9qSnJ7l6iJmSC_5qW45Fq2Tt2RACpxFMSqg,7839
+denonavr/tonecontrol.py,sha256=DfHzziEeLdYiyTbJKcGk5cCPTvKBgjMqQReYp0qoF0U,12474
+denonavr/volume.py,sha256=qnsYr4AWfCu8MQH9mdw1qsaLo3-Sq1mdzreYQDhaTXQ,22260
+denonavr-1.1.0.dist-info/licenses/LICENSE,sha256=hcKXAoZnRee1NRWnxTpKyjKCz4aHhw76sZUZoB3qPTw,1068
+denonavr-1.1.0.dist-info/METADATA,sha256=5fhJJuUm42gutbrRH-VRDqkmp7wXnUQnfuDK7G-xaOk,4707
+denonavr-1.1.0.dist-info/WHEEL,sha256=GHB6lJx2juba1wDgXDNlMTyM13ckjBMKf-OnwgKOCtA,91
+denonavr-1.1.0.dist-info/top_level.txt,sha256=GKwe6bOaw_R68BR7x-C7VD3bDFKKNBf0pRkWywUZWIs,9
+denonavr-1.1.0.dist-info/RECORD,,

{denonavr-1.0.1.dist-info → denonavr-1.1.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (80.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

denonavr-1.0.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-denonavr/__init__.py,sha256=2EHaA5L852gUHTxouwZk4aLyww3HNlkgTPS5CzYkn4w,1325
-denonavr/api.py,sha256=0i68EOx6hhSqGeQaIVw9bpbK7fxLKB_ynR_FtStA2J0,31462
-denonavr/appcommand.py,sha256=H37VK4n-yW0ISvR1hfX8G4udQtGASoY44QNaXtLSidE,7784
-denonavr/audyssey.py,sha256=bHzgFRdUwLQozP2Or59jn6qfYU4WSQxiGKixBx7xxQo,11085
-denonavr/const.py,sha256=HoF8Zn03rC5oiAzl_y4YbYeft6tCKUU95z_GG-sPTMY,21464
-denonavr/decorators.py,sha256=tLoVjGtDmN75fhwCgNREMGjbB6varDERnYlrhC6yIZ8,2733
-denonavr/denonavr.py,sha256=twI100XNXvR6cfqtYKiegjhapOlKBUUSeZFdNBgjUew,24013
-denonavr/exceptions.py,sha256=naP7MCuNH98rv7y_lDdO7ayyvQGywnsfpHhW-o9tKeo,1725
-denonavr/foundation.py,sha256=c8drYLPThQS2cXs6RJbhLMpcb097AA2rC4ofd9fJobA,31432
-denonavr/input.py,sha256=kbKPePkdFHQSHKzOvAYudeSyJiRrUh0PxIOkG38kDUo,43050
-denonavr/soundmode.py,sha256=MKyBtSQ-1gtnNyT_qQhbGDlPQuNS3QzBurjUUWNPKeo,12464
-denonavr/ssdp.py,sha256=4gyvN0yo9qSnJ7l6iJmSC_5qW45Fq2Tt2RACpxFMSqg,7839
-denonavr/tonecontrol.py,sha256=DfHzziEeLdYiyTbJKcGk5cCPTvKBgjMqQReYp0qoF0U,12474
-denonavr/volume.py,sha256=S3UeyassnErOSqiaS48Q4Vo9QHJTyG1jnyEDSRFOfdw,7341
-denonavr-1.0.1.dist-info/LICENSE,sha256=hcKXAoZnRee1NRWnxTpKyjKCz4aHhw76sZUZoB3qPTw,1068
-denonavr-1.0.1.dist-info/METADATA,sha256=CNw5cVpYvc3owjqaBB0Q3beEDgDB4sohaqD9A9nnDck,5233
-denonavr-1.0.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-denonavr-1.0.1.dist-info/top_level.txt,sha256=GKwe6bOaw_R68BR7x-C7VD3bDFKKNBf0pRkWywUZWIs,9
-denonavr-1.0.1.dist-info/RECORD,,