denonavr 1.0.0__py3-none-any.whl → 1.0.1__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.0.1"
 
 
 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()
@@ -543,7 +606,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 +645,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 +659,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 +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(
@@ -618,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(

denonavr/const.py

@@ -274,7 +274,6 @@ SOUND_MODE_MAPPING = {
         "MULTI IN + DOLBY SURROUND",
         "MULTI IN + DSUR",
         "MULTI IN + NEURAL:X",
-        "NEURAL:X",
         "NEURAL",
         "STANDARD(DOLBY)",
     ],
@@ -294,6 +293,7 @@ SOUND_MODE_MAPPING = {
         "DTS:X",
         "M CH IN+DSUR",
         "MULTI CH IN",
+        "NEURAL:X",
         "STANDARD(DTS)",
         "VIRTUAL:X",
     ],

denonavr/decorators.py

@@ -10,14 +10,11 @@ This module implements the REST API to Denon AVR receivers.
 import inspect
 import logging
 import time
-import xml.etree.ElementTree as ET
 from functools import wraps
 from typing import Callable, TypeVar
 
 import httpx
 from asyncstdlib import lru_cache
-from defusedxml import DefusedXmlException
-from defusedxml.ElementTree import ParseError
 
 from .exceptions import (
     AvrForbiddenError,
@@ -33,12 +30,7 @@ AnyT = TypeVar("AnyT")
 
 
 def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[..., AnyT]:
-    """
-    Handle exceptions raised when calling a Denon AVR endpoint asynchronously.
-
-    The decorated function must either have a string variable as second
-    argument or as "request" keyword argument.
-    """
+    """Handle exceptions raised when calling a Denon AVR endpoint asynchronously."""
 
     @wraps(func)
     async def wrapper(*args, **kwargs):
@@ -64,48 +56,29 @@ def async_handle_receiver_exceptions(func: Callable[..., AnyT]) -> Callable[...,
             raise AvrInvalidResponseError(
                 f"RemoteProtocolError: {err}", err.request
             ) from err
-        except (
-            ET.ParseError,
-            DefusedXmlException,
-            ParseError,
-            UnicodeDecodeError,
-        ) as err:
-            _LOGGER.debug(
-                "Defusedxml parse error on request %s: %s", (args, kwargs), err
-            )
-            raise AvrInvalidResponseError(
-                f"XMLParseError: {err}", (args, kwargs)
-            ) from err
 
     return wrapper
 
 
 def cache_result(func: Callable[..., AnyT]) -> Callable[..., AnyT]:
     """
-    Decorate a function to cache its results with an lru_cache of maxsize 16.
+    Decorate a function to cache its results with an lru_cache of maxsize 32.
 
     This decorator also sets an "cache_id" keyword argument if it is not set yet.
-    When an exception occurs it clears lru_cache to prevent memory leaks in
-    home-assistant when receiver instances are created and deleted right
-    away in case the device is offline on setup.
     """
     if inspect.signature(func).parameters.get("cache_id") is None:
         raise AttributeError(
             f"Function {func} does not have a 'cache_id' keyword parameter"
         )
 
-    lru_decorator = lru_cache(maxsize=16)
+    lru_decorator = lru_cache(maxsize=32)
     cached_func = lru_decorator(func)
 
     @wraps(func)
     async def wrapper(*args, **kwargs):
         if kwargs.get("cache_id") is None:
             kwargs["cache_id"] = time.time()
-        try:
-            return await cached_func(*args, **kwargs)
-        except Exception as err:
-            _LOGGER.debug("Exception raised, clearing cache: %s", err)
-            cached_func.cache_clear()
-            raise
+
+        return await cached_func(*args, **kwargs)
 
     return wrapper

denonavr/denonavr.py

@@ -519,7 +519,7 @@ class DenonAVR(DenonAVRFoundation):
         """
         if not callable(async_client_getter):
             raise AvrCommandError("Provided object is not callable")
-        self._device.api.async_client_getter = async_client_getter
+        self._device.api.httpx_async_client.client_getter = async_client_getter
 
     async def async_dynamic_eq_off(self) -> None:
         """Turn DynamicEQ off."""

denonavr/foundation.py

@@ -15,7 +15,6 @@ from copy import deepcopy
 from typing import Dict, List, Optional, Union
 
 import attr
-import httpx
 
 from .api import DenonAVRApi, DenonAVRTelnetApi
 from .appcommand import AppCommandCmd, AppCommands
@@ -146,15 +145,15 @@ class DenonAVRDeviceInfo:
             _LOGGER.debug("Starting device setup")
             # Reduce read timeout during receiver identification
             # deviceinfo endpoint takes very long to return 404
-            timeout = self.api.timeout
-            self.api.timeout = httpx.Timeout(self.api.timeout.connect)
+            read_timeout = self.api.read_timeout
+            self.api.read_timeout = self.api.timeout
             try:
                 _LOGGER.debug("Identifying receiver")
                 await self.async_identify_receiver()
                 _LOGGER.debug("Getting device info")
                 await self.async_get_device_info()
             finally:
-                self.api.timeout = timeout
+                self.api.read_timeout = read_timeout
             _LOGGER.debug("Identifying update method")
             await self.async_identify_update_method()
 
@@ -323,7 +322,7 @@ class DenonAVRDeviceInfo:
                 self._set_friendly_name(xml)
 
     async def async_verify_avr_2016_update_method(
-        self, cache_id: Hashable = None
+        self, *, cache_id: Hashable = None
     ) -> None:
         """Verify if avr 2016 update method is working."""
         # Nothing to do if Appcommand.xml interface is not supported
@@ -833,9 +832,9 @@ def set_api_timeout(
 ) -> float:
     """Change API timeout on timeout changes too."""
     # First change _device.api.host then return value
-    timeout = httpx.Timeout(value, read=max(value, 15.0))
     # pylint: disable=protected-access
-    instance._device.api.timeout = timeout
+    instance._device.api.timeout = value
+    instance._device.api.read_timeout = max(value, 15.0)
     instance._device.telnet_api.timeout = value
     return value
 

denonavr/input.py

@@ -168,6 +168,13 @@ class DenonAVRInput(DenonAVRFoundation):
         converter=attr.converters.optional(str), default=None
     )
 
+    _renamed_sources_warnings: Set[Tuple[str, str]] = attr.ib(
+        validator=attr.validators.deep_iterable(
+            attr.validators.instance_of(tuple), attr.validators.instance_of(set)
+        ),
+        default=attr.Factory(set),
+    )
+
     # Update tags for attributes
     # AppCommand.xml interface
     appcommand_attrs = {AppCommands.GetAllZoneSource: None}
@@ -516,6 +523,8 @@ class DenonAVRInput(DenonAVRFoundation):
             except AttributeError:
                 continue
 
+        self._replace_duplicate_sources(renamed_sources)
+
         return (renamed_sources, deleted_sources)
 
     async def async_get_changed_sources_status_xml(
@@ -604,6 +613,8 @@ class DenonAVRInput(DenonAVRFoundation):
             except IndexError:
                 _LOGGER.error("List of deleted sources incomplete, continuing anyway")
 
+        self._replace_duplicate_sources(renamed_sources)
+
         return (renamed_sources, deleted_sources)
 
     async def async_update_inputfuncs(
@@ -859,10 +870,13 @@ class DenonAVRInput(DenonAVRFoundation):
     async def _async_test_image_accessible(self) -> None:
         """Test if image URL is accessible."""
         if self._image_available is None and self._image_url is not None:
-            client = self._device.api.async_client_getter()
+            client = self._device.api.httpx_async_client.client_getter()
             try:
                 res = await client.get(
-                    self._image_url, timeout=self._device.api.timeout
+                    self._image_url,
+                    timeout=httpx.Timeout(
+                        self._device.api.timeout, read=self._device.api.read_timeout
+                    ),
                 )
                 res.raise_for_status()
             except httpx.TimeoutException:
@@ -878,7 +892,7 @@ class DenonAVRInput(DenonAVRFoundation):
                 self._image_available = True
             finally:
                 # Close the default AsyncClient but keep custom clients open
-                if self._device.api.is_default_async_client():
+                if self._device.api.httpx_async_client.is_default_async_client():
                     await client.aclose()
         # Already tested that image URL is not accessible
         elif not self._image_available:
@@ -894,6 +908,33 @@ class DenonAVRInput(DenonAVRFoundation):
         self._station = None
         self._image_url = None
 
+    def _replace_duplicate_sources(self, sources: Dict[str, str]) -> None:
+        """Replace duplicate renamed sources (values) with their original names."""
+        seen_values = set()
+        duplicate_values = set()
+
+        for value in sources.values():
+            if value in seen_values:
+                duplicate_values.add(value)
+            seen_values.add(value)
+
+        for duplicate in duplicate_values:
+            for key, value in sources.items():
+                if value == duplicate:
+                    sources[key] = key
+
+                    if (key, value) not in self._renamed_sources_warnings:
+                        _LOGGER.warning(
+                            (
+                                "Input source '%s' is renamed to non-unique name '%s'. "
+                                "Using original name. Please choose unique names in "
+                                "your receiver's web-interface"
+                            ),
+                            key,
+                            value,
+                        )
+                        self._renamed_sources_warnings.add((key, value))
+
     ##############
     # Properties #
     ##############

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: denonavr
-Version: 1.0.0
+Version: 1.0.1
 Summary: Automation Library for Denon AVR receivers
 Author-email: Oliver Goetz <scarface@mywoh.de>
 License: MIT
@@ -24,23 +24,23 @@ 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"
+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'
+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)

denonavr-1.0.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+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,,

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

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

denonavr-1.0.0.dist-info/RECORD

@@ -1,19 +0,0 @@
-denonavr/__init__.py,sha256=jkmT2PjmR9ncL4gwegkmN0UMpyA7a2OQn7nU9nbqbZk,1325
-denonavr/api.py,sha256=IL8KMUj6_S_9sFC_DnlmYV0shjfI4lYu7HO3Yb-WjdE,29167
-denonavr/appcommand.py,sha256=H37VK4n-yW0ISvR1hfX8G4udQtGASoY44QNaXtLSidE,7784
-denonavr/audyssey.py,sha256=bHzgFRdUwLQozP2Or59jn6qfYU4WSQxiGKixBx7xxQo,11085
-denonavr/const.py,sha256=lbM3hKYWUd8cto3BUqplKvDpX_uvCr8-7KWWoyohkNE,21464
-denonavr/decorators.py,sha256=yBAMcY3bFJs5DJFZ-7Zvln4_jjcjrux6js4lJoOM59I,3755
-denonavr/denonavr.py,sha256=BUseoHsI4J-ApawMWW_63b61Nn9TasTR0rENiijRW0w,24000
-denonavr/exceptions.py,sha256=naP7MCuNH98rv7y_lDdO7ayyvQGywnsfpHhW-o9tKeo,1725
-denonavr/foundation.py,sha256=fUpOgMO9mgKSq8VW00QSZy75H-mfiIrrKrxqfTiBgfI,31443
-denonavr/input.py,sha256=R9bMCUQYSU02SL3U-uC2bYBKzMd9nVLjRjM4JRvONbo,41408
-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.0.dist-info/LICENSE,sha256=hcKXAoZnRee1NRWnxTpKyjKCz4aHhw76sZUZoB3qPTw,1068
-denonavr-1.0.0.dist-info/METADATA,sha256=QsdEw_wHlMK5pthVZU2wP7bJu9eToruOQQgWpYkGFOw,5250
-denonavr-1.0.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-denonavr-1.0.0.dist-info/top_level.txt,sha256=GKwe6bOaw_R68BR7x-C7VD3bDFKKNBf0pRkWywUZWIs,9
-denonavr-1.0.0.dist-info/RECORD,,