python-linkplay 0.0.5__tar.gz → 0.0.7__tar.gz

{python_linkplay-0.0.5/src/python_linkplay.egg-info → python_linkplay-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python_linkplay
-Version: 0.0.5
+Version: 0.0.7
 Summary: A Python Library for Seamless LinkPlay Device Control
 Author: Velleman Group nv
 License: MIT
@@ -10,16 +10,19 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: async-timeout>=4.0.3
 Requires-Dist: aiohttp>=3.8.5
+Requires-Dist: appdirs>=1.4.4
 Requires-Dist: async_upnp_client>=0.36.2
+Requires-Dist: deprecated>=1.2.14
 Provides-Extra: testing
 Requires-Dist: pytest>=7.3.1; extra == "testing"
 Requires-Dist: pytest-cov>=4.1.0; extra == "testing"
 Requires-Dist: pytest-mock>=3.10.0; extra == "testing"
 Requires-Dist: pytest-asyncio>=0.23.3; extra == "testing"
 Requires-Dist: mypy>=1.3.0; extra == "testing"
-Requires-Dist: flake8>=6.0.0; extra == "testing"
+Requires-Dist: ruff>=0.5.4; extra == "testing"
 Requires-Dist: tox>=4.6.0; extra == "testing"
 Requires-Dist: typing-extensions>=4.6.3; extra == "testing"
+Requires-Dist: pre-commit>=3.8.0; extra == "testing"
 
 
 [![PyPI package](https://badge.fury.io/py/python-linkplay.svg)](https://pypi.org/project/python-linkplay/)

{python_linkplay-0.0.5 → python_linkplay-0.0.7}/pyproject.toml

@@ -25,4 +25,7 @@ warn_redundant_casts = true
 warn_return_any = true
 warn_unreachable = true
 warn_unused_configs = true
-no_implicit_reexport = true
+no_implicit_reexport = true
+
+[tool.ruff.lint]
+select = ["I"]

{python_linkplay-0.0.5 → python_linkplay-0.0.7}/setup.cfg

@@ -14,7 +14,9 @@ packages = find_namespace:
 install_requires = 
 	async-timeout>=4.0.3
 	aiohttp>=3.8.5
+	appdirs>=1.4.4
 	async_upnp_client>=0.36.2
+	deprecated>=1.2.14
 python_requires = >=3.11
 package_dir = 
 	=src
@@ -33,14 +35,10 @@ testing =
 	pytest-mock>=3.10.0
 	pytest-asyncio>=0.23.3
 	mypy>=1.3.0
-	flake8>=6.0.0
+	ruff>=0.5.4
 	tox>=4.6.0
 	typing-extensions>=4.6.3
-
-[flake8]
-max-line-length = 160
-per-file-ignores = 
-	*/__init__.py: F401
+	pre-commit>=3.8.0
 
 [egg_info]
 tag_build = 

{python_linkplay-0.0.5 → python_linkplay-0.0.7}/src/linkplay/__main__.py

@@ -1,11 +1,11 @@
 import asyncio
-import aiohttp
 
 from linkplay.controller import LinkPlayController
+from linkplay.utils import create_unverified_client_session
 
 
 async def main():
-    async with aiohttp.ClientSession() as session:
+    async with create_unverified_client_session() as session:
         controller = LinkPlayController(session)
 
         await controller.discover_bridges()
@@ -16,5 +16,6 @@ async def main():
         for multiroom in controller.multirooms:
             print(multiroom.followers)
 
+
 if __name__ == "__main__":
     asyncio.run(main())

python_linkplay-0.0.7/src/linkplay/__version__.py

@@ -0,0 +1 @@
+__version__ = '0.0.7'

{python_linkplay-0.0.5 → python_linkplay-0.0.7}/src/linkplay/bridge.py

@@ -1,32 +1,34 @@
 from __future__ import annotations
+
 from typing import Any
-from aiohttp import ClientSession
 
 from linkplay.consts import (
+    INPUT_MODE_MAP,
+    PLAY_MODE_SEND_MAP,
     ChannelType,
-    LinkPlayCommand,
     DeviceAttribute,
-    PlayerAttribute,
-    MuteMode,
     EqualizerMode,
+    InputMode,
+    LinkPlayCommand,
     LoopMode,
-    PLAY_MODE_SEND_MAP,
+    MultiroomAttribute,
+    MuteMode,
+    PlayerAttribute,
+    PlayingMode,
     PlayingStatus,
-    InputMode,
     SpeakerType,
-    PlayingMode,
-    INPUT_MODE_MAP,
-    MultiroomAttribute
 )
-
-from linkplay.utils import session_call_api_json, session_call_api_ok, decode_hexstr
+from linkplay.endpoint import LinkPlayEndpoint
+from linkplay.utils import decode_hexstr
 
 
-class LinkPlayDevice():
+class LinkPlayDevice:
     """Represents a LinkPlay device."""
 
     bridge: LinkPlayBridge
-    properties: dict[DeviceAttribute, str] = dict.fromkeys(DeviceAttribute.__members__.values(), "")
+    properties: dict[DeviceAttribute, str] = dict.fromkeys(
+        DeviceAttribute.__members__.values(), ""
+    )
 
     def __init__(self, bridge: LinkPlayBridge):
         self.bridge = bridge
@@ -42,31 +44,39 @@ class LinkPlayDevice():
     @property
     def uuid(self) -> str:
         """The UUID of the device."""
-        return self.properties[DeviceAttribute.UUID]
+        return self.properties.get(DeviceAttribute.UUID, "")
 
     @property
     def name(self) -> str:
         """The name of the device."""
-        return self.properties[DeviceAttribute.DEVICE_NAME]
+        return self.properties.get(DeviceAttribute.DEVICE_NAME, "")
 
     @property
     def playmode_support(self) -> list[PlayingMode]:
         """Returns the player playmode support."""
 
-        flags = InputMode(int(self.properties[DeviceAttribute.PLAYMODE_SUPPORT], base=16))
+        flags = InputMode(
+            int(self.properties[DeviceAttribute.PLAYMODE_SUPPORT], base=16)
+        )
         return [INPUT_MODE_MAP[flag] for flag in flags]
 
     @property
     def eth(self) -> str:
         """Returns the ethernet address."""
-        return self.properties[DeviceAttribute.ETH_DHCP]
+        return (
+            self.properties[DeviceAttribute.ETH_DHCP]
+            if DeviceAttribute.ETH_DHCP in self.properties
+            else self.properties[DeviceAttribute.ETH0]
+        )
 
 
-class LinkPlayPlayer():
+class LinkPlayPlayer:
     """Represents a LinkPlay player."""
 
     bridge: LinkPlayBridge
-    properties: dict[PlayerAttribute, str] = dict.fromkeys(PlayerAttribute.__members__.values(), "")
+    properties: dict[PlayerAttribute, str] = dict.fromkeys(
+        PlayerAttribute.__members__.values(), ""
+    )
 
     def __init__(self, bridge: LinkPlayBridge):
         self.bridge = bridge
@@ -134,111 +144,104 @@ class LinkPlayPlayer():
 
     async def set_play_mode(self, mode: PlayingMode) -> None:
         """Set the play mode."""
-        await self.bridge.request(LinkPlayCommand.SWITCH_MODE.format(PLAY_MODE_SEND_MAP[mode]))  # type: ignore[str-format]
+        await self.bridge.request(
+            LinkPlayCommand.SWITCH_MODE.format(PLAY_MODE_SEND_MAP[mode])
+        )  # type: ignore[str-format]
 
     @property
     def muted(self) -> bool:
         """Returns if the player is muted."""
-        return self.properties[PlayerAttribute.MUTED] == MuteMode.MUTED
+        return self.properties.get(PlayerAttribute.MUTED, MuteMode.UNMUTED) == MuteMode.MUTED
 
     @property
     def title(self) -> str:
         """Returns if the currently playing title of the track."""
-        return self.properties[PlayerAttribute.TITLE]
+        return self.properties.get(PlayerAttribute.TITLE, "")
 
     @property
     def artist(self) -> str:
         """Returns if the currently playing artist."""
-        return self.properties[PlayerAttribute.ARTIST]
+        return self.properties.get(PlayerAttribute.ARTIST, "")
 
     @property
     def album(self) -> str:
         """Returns if the currently playing album."""
-        return self.properties[PlayerAttribute.ALBUM]
+        return self.properties.get(PlayerAttribute.ALBUM, "")
 
     @property
     def volume(self) -> int:
         """Returns the player volume, expressed in %."""
-        return int(self.properties[PlayerAttribute.VOLUME])
+        return int(self.properties.get(PlayerAttribute.VOLUME, 0))
 
     @property
     def current_position(self) -> int:
         """Returns the current position of the track in milliseconds."""
-        return int(self.properties[PlayerAttribute.CURRENT_POSITION])
+        return int(self.properties.get(PlayerAttribute.CURRENT_POSITION, 0))
 
     @property
     def total_length(self) -> int:
         """Returns the total length of the track in milliseconds."""
-        return int(self.properties[PlayerAttribute.TOTAL_LENGTH])
+        return int(self.properties.get(PlayerAttribute.TOTAL_LENGTH, 0))
 
     @property
     def status(self) -> PlayingStatus:
         """Returns the current playing status."""
-        return PlayingStatus(self.properties[PlayerAttribute.PLAYING_STATUS])
+        return PlayingStatus(self.properties.get(PlayerAttribute.PLAYING_STATUS, PlayingStatus.STOPPED))
 
     @property
     def equalizer_mode(self) -> EqualizerMode:
         """Returns the current equalizer mode."""
-        return EqualizerMode(self.properties[PlayerAttribute.EQUALIZER_MODE])
+        return EqualizerMode(self.properties.get(PlayerAttribute.EQUALIZER_MODE, EqualizerMode.CLASSIC))
 
     @property
     def speaker_type(self) -> SpeakerType:
         """Returns the current speaker the player is playing on."""
-        return SpeakerType(self.properties[PlayerAttribute.SPEAKER_TYPE])
+        return SpeakerType(self.properties.get(PlayerAttribute.SPEAKER_TYPE, SpeakerType.MAIN_SPEAKER))
 
     @property
     def channel_type(self) -> ChannelType:
         """Returns the channel the player is playing on."""
-        return ChannelType(self.properties[PlayerAttribute.CHANNEL_TYPE])
+        return ChannelType(self.properties.get(PlayerAttribute.CHANNEL_TYPE, ChannelType.STEREO))
 
     @property
     def play_mode(self) -> PlayingMode:
         """Returns the current playing mode of the player."""
-        return PlayingMode(self.properties[PlayerAttribute.PLAYBACK_MODE])
+        return PlayingMode(self.properties.get(PlayerAttribute.PLAYBACK_MODE, PlayingMode.IDLE))
 
     @property
     def loop_mode(self) -> LoopMode:
         """Returns the current playlist mode."""
-        return LoopMode(self.properties[PlayerAttribute.PLAYLIST_MODE])
+        return LoopMode(self.properties.get(PlayerAttribute.PLAYLIST_MODE, LoopMode.CONTINUOUS_PLAYBACK))
 
 
-class LinkPlayBridge():
+class LinkPlayBridge:
     """Represents a LinkPlay bridge to control the device and player attached to it."""
 
-    protocol: str
-    ip_address: str
-    session: ClientSession
+    endpoint: LinkPlayEndpoint
     device: LinkPlayDevice
     player: LinkPlayPlayer
 
-    def __init__(self, protocol: str, ip_address: str, session: ClientSession):
-        self.protocol = protocol
-        self.ip_address = ip_address
-        self.session = session
+    def __init__(self, *, endpoint: LinkPlayEndpoint):
+        self.endpoint = endpoint
         self.device = LinkPlayDevice(self)
         self.player = LinkPlayPlayer(self)
 
-    def __repr__(self) -> str:
+    def __str__(self) -> str:
         if self.device.name == "":
-            return self.endpoint
+            return f"{self.endpoint}"
 
         return self.device.name
 
-    @property
-    def endpoint(self) -> str:
-        """Returns the current player endpoint."""
-        return f"{self.protocol}://{self.ip_address}"
-
     async def json_request(self, command: str) -> dict[str, str]:
         """Performs a GET request on the given command and returns the result as a JSON object."""
-        return await session_call_api_json(self.endpoint, self.session, command)
+        return await self.endpoint.json_request(command)
 
     async def request(self, command: str) -> None:
         """Performs a GET request on the given command and verifies the result."""
-        await session_call_api_ok(self.endpoint, self.session, command)
+        await self.endpoint.request(command)
 
 
-class LinkPlayMultiroom():
+class LinkPlayMultiroom:
     """Represents a LinkPlay multiroom group. Contains a leader and a list of followers.
     The leader is the device that controls the group."""
 
@@ -251,14 +254,21 @@ class LinkPlayMultiroom():
 
     async def update_status(self, bridges: list[LinkPlayBridge]) -> None:
         """Updates the multiroom status."""
-        properties: dict[Any, Any] = await self.leader.json_request(LinkPlayCommand.MULTIROOM_LIST)
+        properties: dict[Any, Any] = await self.leader.json_request(
+            LinkPlayCommand.MULTIROOM_LIST
+        )
 
         self.followers = []
         if int(properties[MultiroomAttribute.NUM_FOLLOWERS]) == 0:
             return
 
-        follower_uuids = [follower[MultiroomAttribute.UUID] for follower in properties[MultiroomAttribute.FOLLOWER_LIST]]
-        new_followers = [bridge for bridge in bridges if bridge.device.uuid in follower_uuids]
+        follower_uuids = [
+            follower[MultiroomAttribute.UUID]
+            for follower in properties[MultiroomAttribute.FOLLOWER_LIST]
+        ]
+        new_followers = [
+            bridge for bridge in bridges if bridge.device.uuid in follower_uuids
+        ]
         self.followers.extend(new_followers)
 
     async def ungroup(self) -> None:
@@ -268,12 +278,16 @@ class LinkPlayMultiroom():
 
     async def add_follower(self, follower: LinkPlayBridge) -> None:
         """Adds a follower to the multiroom group."""
-        await follower.request(LinkPlayCommand.MULTIROOM_JOIN.format(self.leader.device.eth))  # type: ignore[str-format]
+        await follower.request(
+            LinkPlayCommand.MULTIROOM_JOIN.format(self.leader.device.eth)
+        )  # type: ignore[str-format]
         self.followers.append(follower)
 
     async def remove_follower(self, follower: LinkPlayBridge) -> None:
         """Removes a follower from the multiroom group."""
-        await self.leader.request(LinkPlayCommand.MULTIROOM_KICK.format(follower.device.eth))  # type: ignore[str-format]
+        await self.leader.request(
+            LinkPlayCommand.MULTIROOM_KICK.format(follower.device.eth)
+        )  # type: ignore[str-format]
         self.followers.remove(follower)
 
     async def set_volume(self, value: int) -> None:

{python_linkplay-0.0.5 → python_linkplay-0.0.7}/src/linkplay/consts.py

@@ -1,18 +1,72 @@
-from enum import StrEnum, IntFlag
+from enum import IntFlag, StrEnum
 
 API_ENDPOINT: str = "{}/httpapi.asp?command={}"
 API_TIMEOUT: int = 2
 UNKNOWN_TRACK_PLAYING: str = "Unknown"
-UPNP_DEVICE_TYPE = 'urn:schemas-upnp-org:device:MediaRenderer:1'
+UPNP_DEVICE_TYPE = "urn:schemas-upnp-org:device:MediaRenderer:1"
+
+MTLS_CERTIFICATE_CONTENTS = """
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCk/u2tH0LwCOv8
+JmqLvQdjNAdkxfSCPwrdHM7STlq5xaJGQe29yd8kjP7h0wERkeO/9JO62wUHBu0P
+WIsS/jwLG+G3oAU+7BNfjmBhDXyHIRQLzAWEbtxbsSTke1losfvlQXGumXrMqf9X
+LdIYvbA53mp8GImQbJkaCDvwnEdUFkuJ0W5Tofr58jJqfCt6OPwHmnP4oC6LpPtJ
+YDy7r1Q9sLgCYEtDEw/Mhf+mKuC0pnst52e1qceVjvCuUBoeuhk6kpnEbpSdEKbD
+bdE8cPoVRmrj1//PLFMVtNB7k2aPMb3CcoJ/dHxaCXwk9b3jIBs6CyWixN92CuaO
+Q98Ug/YlAgMBAAECggEAHyCpHlwjeL12J9/nge1rk1+hdXWTJ29VUVm5+xslKp8K
+ek6912xaWL7w5xGzxejMGs69gCcJz8WSu65srmygT0g3UTkzRCetj/2AWU7+C1BG
+Q+N9tvpjQDkvSJusxn+tkhbCp7n03N/FeGEAngJLWN+JH1hRu5mBWNPs2vvgyRAO
+Cv95G7uENavCUXcyYsKPoAfz3ebD/idwwWW2RKAd0ufYeafiFC0ImTLcpEjBvCTW
+UoAniBSVx1PHK4IAUb3pMdPtIv1uBlIMotHS/GdEyHU6qOsX5ijHqncHHneaytmL
++wJukPqASEBl3F2UnzryBUgGqr1wyH9vtPGjklnngQKBgQDZv3oxZWul//2LV+jo
+ZipbnP6nwG3J6pOWPDD3dHoZ6Q2DRyJXN5ty40PS393GVvrSJSdRGeD9+ox5sFoj
+iUMgd6kHG4ME7Fre57zUkqy1Ln1K1fkP5tBUD0hviigHBWih2/Nyl2vrdvX5Wpxx
+5r42UQa9nOzrNB03DTOhDrUszQKBgQDB+xdMRNSFfCatQj+y2KehcH9kaANPvT0l
+l9vgb72qks01h05GSPBZnT1qfndh/Myno9KuVPhJ0HrVwRAjZTd4T69fAH3imW+R
+7HP+RgDen4SRTxj6UTJh2KZ8fdPeCby1xTwxYNjq8HqpiO6FHZpE+l4FE8FalZK+
+Z3GhE7DuuQKBgDq7b+0U6xVKWAwWuSa+L9yoGvQKblKRKB/Uumx0iV6lwtRPAo89
+23sAm9GsOnh+C4dVKCay8UHwK6XDEH0XT/jY7cmR/SP90IDhRsibi2QPVxIxZs2I
+N1cFDEexnxxNtCw8VIzrFNvdKXmJnDsIvvONpWDNjAXg96RatjtR6UJdAoGBAIAx
+HU5r1j54s16gf1QD1ZPcsnN6QWX622PynX4OmjsVVMPhLRtJrHysax/rf52j4OOQ
+YfSPdp3hRqvoMHATvbqmfnC79HVBjPfUWTtaq8xzgro8mXcjHbaH5E41IUSFDs7Z
+D1Raej+YuJc9RNN3orGe+29DhO4GFrn5xp/6UV0RAoGBAKUdRgryWzaN4auzWaRD
+lxoMhlwQdCXzBI1YLH2QUL8elJOHMNfmja5G9iW07ZrhhvQBGNDXFbFrX4hI3c/0
+JC3SPhaaedIjOe9Qd3tn5KgYxbBnWnCTt0kxgro+OM3ORgJseSWbKdRrjOkUxkab
+/NDvel7IF63U4UEkrVVt1bYg
+-----END PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIIDmDCCAoACAQEwDQYJKoZIhvcNAQELBQAwgZExCzAJBgNVBAYTAkNOMREwDwYD
+VQQIDAhTaGFuZ2hhaTERMA8GA1UEBwwIU2hhbmdoYWkxETAPBgNVBAoMCExpbmtw
+bGF5MQwwCgYDVQQLDANpbmMxGTAXBgNVBAMMEHd3dy5saW5rcGxheS5jb20xIDAe
+BgkqhkiG9w0BCQEWEW1haWxAbGlua3BsYXkuY29tMB4XDTE4MTExNTAzMzI1OVoX
+DTQ2MDQwMTAzMzI1OVowgZExCzAJBgNVBAYTAkNOMREwDwYDVQQIDAhTaGFuZ2hh
+aTERMA8GA1UEBwwIU2hhbmdoYWkxETAPBgNVBAoMCExpbmtwbGF5MQwwCgYDVQQL
+DANpbmMxGTAXBgNVBAMMEHd3dy5saW5rcGxheS5jb20xIDAeBgkqhkiG9w0BCQEW
+EW1haWxAbGlua3BsYXkuY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEApP7trR9C8Ajr/CZqi70HYzQHZMX0gj8K3RzO0k5aucWiRkHtvcnfJIz+4dMB
+EZHjv/STutsFBwbtD1iLEv48Cxvht6AFPuwTX45gYQ18hyEUC8wFhG7cW7Ek5HtZ
+aLH75UFxrpl6zKn/Vy3SGL2wOd5qfBiJkGyZGgg78JxHVBZLidFuU6H6+fIyanwr
+ejj8B5pz+KAui6T7SWA8u69UPbC4AmBLQxMPzIX/pirgtKZ7LedntanHlY7wrlAa
+HroZOpKZxG6UnRCmw23RPHD6FUZq49f/zyxTFbTQe5NmjzG9wnKCf3R8Wgl8JPW9
+4yAbOgslosTfdgrmjkPfFIP2JQIDAQABMA0GCSqGSIb3DQEBCwUAA4IBAQARmy6f
+esrifhW5NM9i3xsEVp945iSXhqHgrtIROgrC7F1EIAyoIiBdaOvitZVtsYc7Ivys
+QtyVmEGscyjuYTdfigvwTVVj2oCeFv1Xjf+t/kSuk6X3XYzaxPPnFG4nAe2VwghE
+rbZG0K5l8iXM7Lm+ZdqQaAYVWsQDBG8lbczgkB9q5ed4zbDPf6Fsrsynxji/+xa4
+9ARfyHlkCDBThGNnnl+QITtfOWxm/+eReILUQjhwX+UwbY07q/nUxLlK6yrzyjnn
+wi2B2GovofQ/4icVZ3ecTqYK3q9gEtJi72V+dVHM9kSA4Upy28Y0U1v56uoqeWQ6
+uc2m8y8O/hXPSfKd
+-----END CERTIFICATE-----
+"""
 
 
 class LinkPlayCommand(StrEnum):
     """Defines the LinkPlay commands."""
-    DEVICE_STATUS = "getStatus"
+
+    DEVICE_STATUS = "getStatusEx"
     SYSLOG = "getsyslog"
     UPDATE_SERVER = "GetUpdateServer"
     REBOOT = "reboot"
-    PLAYER_STATUS = "getPlayerStatus"
+    PLAYER_STATUS = "getPlayerStatusEx"
     NEXT = "setPlayerCmd:next"
     PREVIOUS = "setPlayerCmd:prev"
     UNMUTE = "setPlayerCmd:mute:0"
@@ -39,12 +93,14 @@ class LinkPlayCommand(StrEnum):
 
 class SpeakerType(StrEnum):
     """Defines the speaker type."""
+
     MAIN_SPEAKER = "0"
     SUB_SPEAKER = "1"
 
 
 class ChannelType(StrEnum):
     """Defines the channel type."""
+
     STEREO = "0"
     LEFT_CHANNEL = "1"
     RIGHT_CHANNEL = "2"
@@ -52,6 +108,8 @@ class ChannelType(StrEnum):
 
 class PlayingMode(StrEnum):
     """Defines a possible playing mode."""
+
+    DAB = "-96"  # Unmapped
     IDLE = "-1"
     NONE = "0"
     AIRPLAY = "1"
@@ -71,7 +129,6 @@ class PlayingMode(StrEnum):
     SPOTIFY = "31"
     LINE_IN = "40"
     BLUETOOTH = "41"
-    EXT_LOCAL = "42"
     OPTICAL = "43"
     RCA = "44"
     COAXIAL = "45"
@@ -79,57 +136,69 @@ class PlayingMode(StrEnum):
     LINE_IN_2 = "47"
     XLR = "48"
     HDMI = "49"
-    MIRROR = "50"
+    CD = "50"
     USB_DAC = "51"
     TF_CARD_2 = "52"
+    EXTERN_BLUETOOTH = "53"
+    PHONO = "54"
     OPTICAL_2 = "56"
+    COAXIAL_2 = "57"
+    ARC = "58"
     TALK = "60"
-    SLAVE = "99"
+    FOLLOWER = "99"
 
 
 # Map between a play mode and how to activate the play mode
-PLAY_MODE_SEND_MAP: dict[PlayingMode, str] = {     # case sensitive!
-    PlayingMode.NONE: 'Idle',
-    PlayingMode.AIRPLAY: 'Airplay',
-    PlayingMode.DLNA: 'DLNA',
-    PlayingMode.QPLAY: 'QPlay',
-    PlayingMode.NETWORK: 'wifi',
-    PlayingMode.WIIMU_LOCAL: 'udisk',
-    PlayingMode.TF_CARD_1: 'TFcard',
-    PlayingMode.API: 'API',
-    PlayingMode.UDISK: 'udisk',
-    PlayingMode.ALARM: 'Alarm',
-    PlayingMode.SPOTIFY: 'Spotify',
-    PlayingMode.LINE_IN: 'line-in',
-    PlayingMode.BLUETOOTH: 'bluetooth',
-    PlayingMode.OPTICAL: 'optical',
-    PlayingMode.RCA: 'RCA',
-    PlayingMode.COAXIAL: 'co-axial',
-    PlayingMode.FM: 'FM',
-    PlayingMode.LINE_IN_2: 'line-in2',
-    PlayingMode.XLR: 'XLR',
-    PlayingMode.HDMI: 'HDMI',
-    PlayingMode.MIRROR: 'cd',
-    PlayingMode.USB_DAC: 'USB DAC',
-    PlayingMode.TF_CARD_2: 'TFcard',
-    PlayingMode.TALK: 'Talk',
-    PlayingMode.SLAVE: 'Idle',
-    PlayingMode.OPTICAL_2: 'optical2'
+PLAY_MODE_SEND_MAP: dict[PlayingMode, str] = {  # case sensitive!
+    PlayingMode.NONE: "Idle",
+    PlayingMode.AIRPLAY: "Airplay",
+    PlayingMode.DLNA: "DLNA",
+    PlayingMode.QPLAY: "QPlay",
+    PlayingMode.NETWORK: "wifi",
+    PlayingMode.WIIMU_LOCAL: "udisk",
+    PlayingMode.TF_CARD_1: "TFcard",
+    PlayingMode.API: "API",
+    PlayingMode.UDISK: "udisk",
+    PlayingMode.ALARM: "Alarm",
+    PlayingMode.SPOTIFY: "Spotify",
+    PlayingMode.LINE_IN: "line-in",
+    PlayingMode.BLUETOOTH: "bluetooth",
+    PlayingMode.OPTICAL: "optical",
+    PlayingMode.RCA: "RCA",
+    PlayingMode.COAXIAL: "co-axial",
+    PlayingMode.FM: "FM",
+    PlayingMode.LINE_IN_2: "line-in2",
+    PlayingMode.XLR: "XLR",
+    PlayingMode.HDMI: "HDMI",
+    PlayingMode.CD: "cd",
+    PlayingMode.USB_DAC: "PCUSB",
+    PlayingMode.TF_CARD_2: "TFcard",
+    PlayingMode.TALK: "Talk",
+    PlayingMode.FOLLOWER: "Idle",
+    PlayingMode.OPTICAL_2: "optical2",
+    PlayingMode.PHONO: "phono",
+    PlayingMode.COAXIAL_2: "co-axial2",
+    PlayingMode.ARC: "ARC",
+    PlayingMode.DAB: "DAB",
+    PlayingMode.EXTERN_BLUETOOTH: "extern_bluetooth",
 }
 
 
 class LoopMode(StrEnum):
     """Defines the loop mode."""
+
     CONTINOUS_PLAY_ONE_SONG = "-1"
     PLAY_IN_ORDER = "0"
     CONTINUOUS_PLAYBACK = "1"
     RANDOM_PLAYBACK = "2"
     LIST_CYCLE = "3"
-    FOUR = "4"
+    SHUFF_DISABLED_REPEAT_DISABLED = "4"
+    SHUFF_ENABLED_REPEAT_ENABLED_LOOP_ONCE = "5"
 
 
 class EqualizerMode(StrEnum):
     """Defines the equalizer mode."""
+
     NONE = "0"
     CLASSIC = "1"
     POP = "2"
@@ -139,6 +208,7 @@ class EqualizerMode(StrEnum):
 
 class PlayingStatus(StrEnum):
     """Defines the playing status."""
+
     PLAYING = "play"
     LOADING = "load"
     STOPPED = "stop"
@@ -147,20 +217,33 @@ class PlayingStatus(StrEnum):
 
 class MuteMode(StrEnum):
     """Defines the mute mode."""
+
     UNMUTED = "0"
     MUTED = "1"
 
 
 class InputMode(IntFlag):
     """Defines which inputs the player supports."""
+
     LINE_IN = 2
     BLUETOOTH = 4
     USB = 8
     OPTICAL = 16
+    RCA = 32
     COAXIAL = 64
+    FM = 128
     LINE_IN_2 = 256
+    XLR = 512
+    HDMI = 1024
+    CD = 2048
+    TF_CARD_1 = 8192
+    EXTERN_BLUETOOTH = 16384
     USB_DAC = 32768
+    PHONO = 65536
     OPTICAL_2 = 262144
+    COAXIAL_2 = 524288
+    FOLLOWER = 2097152  # unknown: is capable to follow leader?
+    ARC = 4194304
 
 
 # Map between the input modes and the play mode
@@ -169,15 +252,27 @@ INPUT_MODE_MAP: dict[InputMode, PlayingMode] = {
     InputMode.BLUETOOTH: PlayingMode.BLUETOOTH,
     InputMode.USB: PlayingMode.UDISK,
     InputMode.OPTICAL: PlayingMode.OPTICAL,
+    InputMode.RCA: PlayingMode.RCA,
     InputMode.COAXIAL: PlayingMode.COAXIAL,
+    InputMode.FM: PlayingMode.FM,
     InputMode.LINE_IN_2: PlayingMode.LINE_IN_2,
+    InputMode.XLR: PlayingMode.XLR,
+    InputMode.HDMI: PlayingMode.HDMI,
+    InputMode.CD: PlayingMode.CD,
+    InputMode.TF_CARD_1: PlayingMode.TF_CARD_1,
+    InputMode.EXTERN_BLUETOOTH: PlayingMode.EXTERN_BLUETOOTH,
     InputMode.USB_DAC: PlayingMode.USB_DAC,
-    InputMode.OPTICAL_2: PlayingMode.OPTICAL_2
+    InputMode.PHONO: PlayingMode.PHONO,
+    InputMode.OPTICAL_2: PlayingMode.OPTICAL_2,
+    InputMode.COAXIAL_2: PlayingMode.COAXIAL_2,
+    InputMode.FOLLOWER: PlayingMode.FOLLOWER,
+    InputMode.ARC: PlayingMode.ARC,
 }
 
 
 class PlayerAttribute(StrEnum):
     """Defines the player attributes."""
+
     SPEAKER_TYPE = "type"
     CHANNEL_TYPE = "ch"
     PLAYBACK_MODE = "mode"
@@ -199,6 +294,7 @@ class PlayerAttribute(StrEnum):
 
 class DeviceAttribute(StrEnum):
     """Defines the device attributes."""
+
     UUID = "uuid"
     DEVICE_NAME = "DeviceName"
     GROUP_NAME = "GroupName"
@@ -278,10 +374,35 @@ class DeviceAttribute(StrEnum):
     ETH_MAC_ADDRESS = "ETH_MAC"
     SECURITY = "security"
     SECURITY_VERSION = "security_version"
+    FW_RELEASE_VERSION = "FW_Release_version"
+    PCB_VERSION = "PCB_version"
+    EXPIRED = "expired"
+    BT_MAC = "BT_MAC"
+    AP_MAC = "AP_MAC"
+    ETH0 = "eth0"
+    UPDATE_CHECK_COUNT = "update_check_count"
+    BLE_REMOTE_UPDATE_CHECKED_COUNTER = "BleRemote_update_checked_counter"
+    ALEXA_VER = "alexa_ver"
+    ALEXA_BETA_ENABLE = "alexa_beta_enable"
+    ALEXA_FORCE_BETA_CFG = "alexa_force_beta_cfg"
+    VOLUME_CONTROL = "volume_control"
+    WLAN_SNR = "wlanSnr"
+    WLAN_NOISE = "wlanNoise"
+    WLAN_FREQ = "wlanFreq"
+    WLAN_DATA_RATE = "wlanDataRate"
+    OTA_INTERFACE_VER = "ota_interface_ver"
+    EQ_SUPPORT = "EQ_support"
+    AUDIO_CHANNEL_CONFIG = "audio_channel_config"
+    APP_TIMEZONE_ID = "app_timezone_id"
+    AVS_TIMEZONE_ID = "avs_timezone_id"
+    TZ_INFO_VER = "tz_info_ver"
+    POWER_MODE = "power_mode"
+    SECURITY_CAPABILITIES = "security_capabilities"
 
 
 class MultiroomAttribute(StrEnum):
     """Defines the player attributes."""
+
     NUM_FOLLOWERS = "slaves"
     FOLLOWER_LIST = "slave_list"
     UUID = "uuid"

{python_linkplay-0.0.5 → python_linkplay-0.0.7}/src/linkplay/controller.py

@@ -4,7 +4,7 @@ from linkplay.bridge import LinkPlayBridge, LinkPlayMultiroom
 from linkplay.discovery import discover_linkplay_bridges
 
 
-class LinkPlayController():
+class LinkPlayController:
     """Represents a LinkPlay controller to manage the devices and multirooms."""
 
     session: ClientSession
@@ -22,7 +22,11 @@ class LinkPlayController():
         # Discover new bridges
         discovered_bridges = await discover_linkplay_bridges(self.session)
         current_bridges = [bridge.device.uuid for bridge in self.bridges]
-        new_bridges = [discovered_bridge for discovered_bridge in discovered_bridges if discovered_bridge.device.uuid not in current_bridges]
+        new_bridges = [
+            discovered_bridge
+            for discovered_bridge in discovered_bridges
+            if discovered_bridge.device.uuid not in current_bridges
+        ]
         self.bridges.extend(new_bridges)
 
     async def discover_multirooms(self) -> None:
@@ -31,7 +35,9 @@ class LinkPlayController():
         # Create new multirooms from new bridges
         new_multirooms = []
         for bridge in self.bridges:
-            has_multiroom = any(multiroom for multiroom in self.multirooms if multiroom.leader == bridge)
+            has_multiroom = any(
+                multiroom for multiroom in self.multirooms if multiroom.leader == bridge
+            )
 
             if has_multiroom:
                 continue
@@ -46,7 +52,9 @@ class LinkPlayController():
             await multiroom.update_status(self.bridges)
 
         # Remove multirooms if they have no followers
-        empty_multirooms = [multiroom for multiroom in self.multirooms if not multiroom.followers]
+        empty_multirooms = [
+            multiroom for multiroom in self.multirooms if not multiroom.followers
+        ]
         for empty_multiroom in empty_multirooms:
             self.multirooms.remove(empty_multiroom)
 

python_linkplay-0.0.7/src/linkplay/discovery.py

@@ -0,0 +1,118 @@
+from typing import Any
+
+from aiohttp import ClientSession
+from async_upnp_client.search import async_search
+from async_upnp_client.utils import CaseInsensitiveDict
+from deprecated import deprecated
+
+from linkplay.bridge import LinkPlayBridge
+from linkplay.consts import UPNP_DEVICE_TYPE, LinkPlayCommand, MultiroomAttribute
+from linkplay.endpoint import LinkPlayApiEndpoint, LinkPlayEndpoint
+from linkplay.exceptions import LinkPlayRequestException
+
+
+@deprecated(
+    reason="Use linkplay_factory_bridge_endpoint with a LinkPlayEndpoint or linkplay_factory_httpapi_bridge instead.",
+    version="0.0.7",
+)
+async def linkplay_factory_bridge(
+    ip_address: str, session: ClientSession
+) -> LinkPlayBridge | None:
+    """Attempts to create a LinkPlayBridge from the given IP address.
+    Returns None if the device is not an expected LinkPlay device."""
+    endpoint: LinkPlayApiEndpoint = LinkPlayApiEndpoint(
+        protocol="http", endpoint=ip_address, session=session
+    )
+    try:
+        return await linkplay_factory_bridge_endpoint(endpoint)
+    except LinkPlayRequestException:
+        return None
+
+
+async def linkplay_factory_bridge_endpoint(
+    endpoint: LinkPlayEndpoint,
+) -> LinkPlayBridge:
+    """Attempts to create a LinkPlayBridge from given LinkPlayEndpoint.
+    Raises LinkPlayRequestException if the device is not an expected LinkPlay device."""
+
+    bridge: LinkPlayBridge = LinkPlayBridge(endpoint=endpoint)
+    await bridge.device.update_status()
+    await bridge.player.update_status()
+    return bridge
+
+
+async def linkplay_factory_httpapi_bridge(
+    ip_address: str, session: ClientSession
+) -> LinkPlayBridge:
+    """Attempts to create a LinkPlayBridge from the given IP address.
+    Attempts to use HTTPS first, then falls back to HTTP.
+    Raises LinkPlayRequestException if the device is not an expected LinkPlay device."""
+
+    https_endpoint: LinkPlayApiEndpoint = LinkPlayApiEndpoint(
+        protocol="https", endpoint=ip_address, session=session
+    )
+    try:
+        return await linkplay_factory_bridge_endpoint(https_endpoint)
+    except LinkPlayRequestException:
+        http_endpoint: LinkPlayApiEndpoint = LinkPlayApiEndpoint(
+            protocol="http", endpoint=ip_address, session=session
+        )
+        return await linkplay_factory_bridge_endpoint(http_endpoint)
+
+
+async def discover_linkplay_bridges(
+    session: ClientSession, discovery_through_multiroom: bool = True
+) -> list[LinkPlayBridge]:
+    """Attempts to discover LinkPlay devices on the local network."""
+    bridges: dict[str, LinkPlayBridge] = {}
+
+    async def add_linkplay_device_to_list(upnp_device: CaseInsensitiveDict):
+        ip_address: str | None = upnp_device.get("_host")
+
+        if not ip_address:
+            return
+
+        try:
+            bridge = await linkplay_factory_httpapi_bridge(ip_address, session)
+            bridges[bridge.device.uuid] = bridge
+        except LinkPlayRequestException:
+            pass
+
+    await async_search(
+        search_target=UPNP_DEVICE_TYPE, async_callback=add_linkplay_device_to_list
+    )
+
+    # Discover additional bridges through grouped multirooms
+    if discovery_through_multiroom:
+        multiroom_discovered_bridges: dict[str, LinkPlayBridge] = {}
+        for bridge in bridges.values():
+            for new_bridge in await discover_bridges_through_multiroom(bridge, session):
+                multiroom_discovered_bridges[new_bridge.device.uuid] = new_bridge
+
+        bridges = bridges | multiroom_discovered_bridges
+
+    return list(bridges.values())
+
+
+async def discover_bridges_through_multiroom(
+    bridge: LinkPlayBridge, session: ClientSession
+) -> list[LinkPlayBridge]:
+    """Discovers bridges through the multiroom of the provided bridge."""
+    properties: dict[Any, Any] = await bridge.json_request(
+        LinkPlayCommand.MULTIROOM_LIST
+    )
+
+    if int(properties[MultiroomAttribute.NUM_FOLLOWERS]) == 0:
+        return []
+
+    followers: list[LinkPlayBridge] = []
+    for follower in properties[MultiroomAttribute.FOLLOWER_LIST]:
+        try:
+            new_bridge = await linkplay_factory_httpapi_bridge(
+                follower[MultiroomAttribute.IP], session
+            )
+            followers.append(new_bridge)
+        except LinkPlayRequestException:
+            pass
+
+    return followers

python_linkplay-0.0.7/src/linkplay/endpoint.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+
+from aiohttp import ClientSession
+
+from linkplay.utils import session_call_api_json, session_call_api_ok
+
+
+class LinkPlayEndpoint(ABC):
+    """Represents an abstract LinkPlay endpoint."""
+
+    @abstractmethod
+    async def request(self, command: str) -> None:
+        """Performs a request on the given command and verifies the result."""
+
+    @abstractmethod
+    async def json_request(self, command: str) -> dict[str, str]:
+        """Performs a request on the given command and returns the result as a JSON object."""
+
+
+class LinkPlayApiEndpoint(LinkPlayEndpoint):
+    """Represents a LinkPlay HTTP API endpoint."""
+
+    def __init__(self, *, protocol: str, endpoint: str, session: ClientSession):
+        assert protocol in [
+            "http",
+            "https",
+        ], "Protocol must be either 'http' or 'https'"
+        self._endpoint: str = f"{protocol}://{endpoint}"
+        self._session: ClientSession = session
+
+    async def request(self, command: str) -> None:
+        """Performs a GET request on the given command and verifies the result."""
+        await session_call_api_ok(self._endpoint, self._session, command)
+
+    async def json_request(self, command: str) -> dict[str, str]:
+        """Performs a GET request on the given command and returns the result as a JSON object."""
+        return await session_call_api_json(self._endpoint, self._session, command)
+
+    def __str__(self) -> str:
+        return self._endpoint

python_linkplay-0.0.7/src/linkplay/utils.py

@@ -0,0 +1,106 @@
+import asyncio
+import contextlib
+import json
+import os
+import socket
+import ssl
+from http import HTTPStatus
+from typing import Dict
+
+import async_timeout
+from aiohttp import ClientError, ClientSession, TCPConnector
+from appdirs import AppDirs
+
+from linkplay.consts import API_ENDPOINT, API_TIMEOUT, MTLS_CERTIFICATE_CONTENTS
+from linkplay.exceptions import LinkPlayRequestException
+
+
+async def session_call_api(endpoint: str, session: ClientSession, command: str) -> str:
+    """Calls the LinkPlay API and returns the result as a string.
+
+    Args:
+        endpoint (str): The endpoint to use.
+        session (ClientSession): The client session to use.
+        command (str): The command to use.
+
+    Raises:
+        LinkPlayRequestException: Thrown when the request fails or an invalid response is received.
+
+    Returns:
+        str: The response of the API call.
+    """
+    url = API_ENDPOINT.format(endpoint, command)
+
+    try:
+        async with async_timeout.timeout(API_TIMEOUT):
+            response = await session.get(url)
+
+    except (asyncio.TimeoutError, ClientError, asyncio.CancelledError) as error:
+        raise LinkPlayRequestException(
+            f"{error} error requesting data from '{url}'"
+        ) from error
+
+    if response.status != HTTPStatus.OK:
+        raise LinkPlayRequestException(
+            f"Unexpected HTTPStatus {response.status} received from '{url}'"
+        )
+
+    return await response.text()
+
+
+async def session_call_api_json(
+    endpoint: str, session: ClientSession, command: str
+) -> Dict[str, str]:
+    """Calls the LinkPlay API and returns the result as a JSON object."""
+    result = await session_call_api(endpoint, session, command)
+    return json.loads(result)  # type: ignore
+
+
+async def session_call_api_ok(
+    endpoint: str, session: ClientSession, command: str
+) -> None:
+    """Calls the LinkPlay API and checks if the response is OK. Throws exception if not."""
+    result = await session_call_api(endpoint, session, command)
+
+    if result != "OK":
+        raise LinkPlayRequestException(f"Didn't receive expected OK from {endpoint}")
+
+
+def decode_hexstr(hexstr: str) -> str:
+    """Decode a hex string."""
+    try:
+        return bytes.fromhex(hexstr).decode("utf-8")
+    except ValueError:
+        return hexstr
+
+
+def create_unverified_context() -> ssl.SSLContext:
+    """Creates an unverified SSL context with the default mTLS certificate."""
+    dirs = AppDirs("python-linkplay")
+    mtls_certificate_path = os.path.join(dirs.user_data_dir, "linkplay.pem")
+
+    if not os.path.isdir(dirs.user_data_dir):
+        os.makedirs(dirs.user_data_dir, exist_ok=True)
+
+    if not os.path.isfile(mtls_certificate_path):
+        with open(mtls_certificate_path, "w", encoding="utf-8") as file:
+            file.write(MTLS_CERTIFICATE_CONTENTS)
+
+    sslcontext: ssl.SSLContext = ssl.create_default_context(
+        purpose=ssl.Purpose.SERVER_AUTH
+    )
+    sslcontext.load_cert_chain(certfile=mtls_certificate_path)
+    sslcontext.check_hostname = False
+    sslcontext.verify_mode = ssl.CERT_NONE
+    with contextlib.suppress(AttributeError):
+        # This only works for OpenSSL >= 1.0.0
+        sslcontext.options |= ssl.OP_NO_COMPRESSION
+    sslcontext.set_default_verify_paths()
+    return sslcontext
+
+
+def create_unverified_client_session() -> ClientSession:
+    """Creates a ClientSession using the default unverified SSL context"""
+    context: ssl.SSLContext = create_unverified_context()
+    connector: TCPConnector = TCPConnector(family=socket.AF_UNSPEC, ssl=context)
+    return ClientSession(connector=connector)

{python_linkplay-0.0.5 → python_linkplay-0.0.7/src/python_linkplay.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python_linkplay
-Version: 0.0.5
+Version: 0.0.7
 Summary: A Python Library for Seamless LinkPlay Device Control
 Author: Velleman Group nv
 License: MIT
@@ -10,16 +10,19 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: async-timeout>=4.0.3
 Requires-Dist: aiohttp>=3.8.5
+Requires-Dist: appdirs>=1.4.4
 Requires-Dist: async_upnp_client>=0.36.2
+Requires-Dist: deprecated>=1.2.14
 Provides-Extra: testing
 Requires-Dist: pytest>=7.3.1; extra == "testing"
 Requires-Dist: pytest-cov>=4.1.0; extra == "testing"
 Requires-Dist: pytest-mock>=3.10.0; extra == "testing"
 Requires-Dist: pytest-asyncio>=0.23.3; extra == "testing"
 Requires-Dist: mypy>=1.3.0; extra == "testing"
-Requires-Dist: flake8>=6.0.0; extra == "testing"
+Requires-Dist: ruff>=0.5.4; extra == "testing"
 Requires-Dist: tox>=4.6.0; extra == "testing"
 Requires-Dist: typing-extensions>=4.6.3; extra == "testing"
+Requires-Dist: pre-commit>=3.8.0; extra == "testing"
 
 
 [![PyPI package](https://badge.fury.io/py/python-linkplay.svg)](https://pypi.org/project/python-linkplay/)

{python_linkplay-0.0.5 → python_linkplay-0.0.7}/src/python_linkplay.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/linkplay/bridge.py
 src/linkplay/consts.py
 src/linkplay/controller.py
 src/linkplay/discovery.py
+src/linkplay/endpoint.py
 src/linkplay/exceptions.py
 src/linkplay/utils.py
 src/python_linkplay.egg-info/PKG-INFO

{python_linkplay-0.0.5 → python_linkplay-0.0.7}/src/python_linkplay.egg-info/requires.txt

@@ -1,6 +1,8 @@
 async-timeout>=4.0.3
 aiohttp>=3.8.5
+appdirs>=1.4.4
 async_upnp_client>=0.36.2
+deprecated>=1.2.14
 
 [testing]
 pytest>=7.3.1
@@ -8,6 +10,7 @@ pytest-cov>=4.1.0
 pytest-mock>=3.10.0
 pytest-asyncio>=0.23.3
 mypy>=1.3.0
-flake8>=6.0.0
+ruff>=0.5.4
 tox>=4.6.0
 typing-extensions>=4.6.3
+pre-commit>=3.8.0

python_linkplay-0.0.5/src/linkplay/__version__.py

@@ -1 +0,0 @@
-__version__ = '0.0.5'

python_linkplay-0.0.5/src/linkplay/discovery.py

@@ -1,67 +0,0 @@
-from typing import Any
-
-from aiohttp import ClientSession
-from async_upnp_client.search import async_search
-from async_upnp_client.utils import CaseInsensitiveDict
-
-from linkplay.consts import UPNP_DEVICE_TYPE, LinkPlayCommand, MultiroomAttribute
-from linkplay.bridge import LinkPlayBridge
-from linkplay.exceptions import LinkPlayRequestException
-
-
-async def linkplay_factory_bridge(ip_address: str, session: ClientSession) -> LinkPlayBridge | None:
-    """Attempts to create a LinkPlayBridge from the given IP address.
-    Returns None if the device is not an expected LinkPlay device."""
-    bridge = LinkPlayBridge("http", ip_address, session)
-    try:
-        await bridge.device.update_status()
-        await bridge.player.update_status()
-    except LinkPlayRequestException:
-        return None
-    return bridge
-
-
-async def discover_linkplay_bridges(session: ClientSession, discovery_through_multiroom: bool = True) -> list[LinkPlayBridge]:
-    """Attempts to discover LinkPlay devices on the local network."""
-    bridges: dict[str, LinkPlayBridge] = {}
-
-    async def add_linkplay_device_to_list(upnp_device: CaseInsensitiveDict):
-        ip_address: str | None = upnp_device.get('_host')
-
-        if not ip_address:
-            return
-
-        if bridge := await linkplay_factory_bridge(ip_address, session):
-            bridges[bridge.device.uuid] = bridge
-
-    await async_search(
-        search_target=UPNP_DEVICE_TYPE,
-        async_callback=add_linkplay_device_to_list
-    )
-
-    # Discover additional bridges through grouped multirooms
-    if discovery_through_multiroom:
-        multiroom_discovered_bridges: dict[str, LinkPlayBridge] = {}
-        for bridge in bridges.values():
-            for new_bridge in await discover_bridges_through_multiroom(bridge, session):
-                multiroom_discovered_bridges[new_bridge.device.uuid] = new_bridge
-
-        bridges = bridges | multiroom_discovered_bridges
-
-    return list(bridges.values())
-
-
-async def discover_bridges_through_multiroom(bridge: LinkPlayBridge,
-                                             session: ClientSession) -> list[LinkPlayBridge]:
-    """Discovers bridges through the multiroom of the provided bridge."""
-    properties: dict[Any, Any] = await bridge.json_request(LinkPlayCommand.MULTIROOM_LIST)
-
-    if int(properties[MultiroomAttribute.NUM_FOLLOWERS]) == 0:
-        return []
-
-    followers: list[LinkPlayBridge] = []
-    for follower in properties[MultiroomAttribute.FOLLOWER_LIST]:
-        if new_bridge := await linkplay_factory_bridge(follower[MultiroomAttribute.IP], session):
-            followers.append(new_bridge)
-
-    return followers

python_linkplay-0.0.5/src/linkplay/utils.py

@@ -1,62 +0,0 @@
-import asyncio
-from typing import Dict
-import json
-from http import HTTPStatus
-
-import async_timeout
-from aiohttp import ClientSession, ClientError
-
-from linkplay.consts import API_ENDPOINT, API_TIMEOUT
-from linkplay.exceptions import LinkPlayRequestException
-
-
-async def session_call_api(endpoint: str, session: ClientSession, command: str) -> str:
-    """Calls the LinkPlay API and returns the result as a string.
-
-    Args:
-        endpoint (str): The endpoint to use.
-        session (ClientSession): The client session to use.
-        command (str): The command to use.
-
-    Raises:
-        LinkPlayRequestException: Thrown when the request fails or an invalid response is received.
-
-    Returns:
-        str: The response of the API call.
-    """
-    url = API_ENDPOINT.format(endpoint, command)
-
-    try:
-        async with async_timeout.timeout(API_TIMEOUT):
-            response = await session.get(url, ssl=False)
-
-    except (asyncio.TimeoutError, ClientError, asyncio.CancelledError) as error:
-        raise LinkPlayRequestException(f"Error requesting data from '{url}'") from error
-
-    if response.status != HTTPStatus.OK:
-        raise LinkPlayRequestException(f"Unexpected HTTPStatus {response.status} received from '{url}'")
-
-    return await response.text()
-
-
-async def session_call_api_json(endpoint: str, session: ClientSession,
-                                command: str) -> Dict[str, str]:
-    """Calls the LinkPlay API and returns the result as a JSON object."""
-    result = await session_call_api(endpoint, session, command)
-    return json.loads(result)  # type: ignore
-
-
-async def session_call_api_ok(endpoint: str, session: ClientSession, command: str) -> None:
-    """Calls the LinkPlay API and checks if the response is OK. Throws exception if not."""
-    result = await session_call_api(endpoint, session, command)
-
-    if result != "OK":
-        raise LinkPlayRequestException(f"Didn't receive expected OK from {endpoint}")
-
-
-def decode_hexstr(hexstr: str) -> str:
-    """Decode a hex string."""
-    try:
-        return bytes.fromhex(hexstr).decode("utf-8")
-    except ValueError:
-        return hexstr