python-linkplay 0.0.0__tar.gz → 0.0.2__tar.gz

{python_linkplay-0.0.0/src/python_linkplay.egg-info → python_linkplay-0.0.2}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: python_linkplay
-Version: 0.0.0
+Version: 0.0.2
 Summary: A Python Library for Seamless LinkPlay Device Control
 Author: Velleman Group nv
 License: MIT
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: async-timeout==4.0.3
@@ -23,8 +23,7 @@ Requires-Dist: typing-extensions>=4.6.3; extra == "testing"
 
 
 [![PyPI package](https://badge.fury.io/py/python-linkplay.svg)](https://pypi.org/project/python-linkplay/)
-
-[![Release](https://github.com/velleman/python-linkplay/actions/workflows/release/badge.svg)](https://github.com/velleman/python-linkplay/actions/workflows/release.yaml)
+[![Release](https://github.com/velleman/python-linkplay/actions/workflows/release.yaml/badge.svg)](https://github.com/velleman/python-linkplay/actions/workflows/release.yaml)
 
 # python-linkplay
 A Python Library for Seamless LinkPlay Device Control

{python_linkplay-0.0.0 → python_linkplay-0.0.2}/README.md

@@ -1,7 +1,6 @@
 
 [![PyPI package](https://badge.fury.io/py/python-linkplay.svg)](https://pypi.org/project/python-linkplay/)
-
-[![Release](https://github.com/velleman/python-linkplay/actions/workflows/release/badge.svg)](https://github.com/velleman/python-linkplay/actions/workflows/release.yaml)
+[![Release](https://github.com/velleman/python-linkplay/actions/workflows/release.yaml/badge.svg)](https://github.com/velleman/python-linkplay/actions/workflows/release.yaml)
 
 # python-linkplay
 A Python Library for Seamless LinkPlay Device Control

{python_linkplay-0.0.0 → python_linkplay-0.0.2}/setup.cfg

@@ -15,7 +15,7 @@ install_requires =
 	async-timeout==4.0.3
 	aiohttp==3.9.1
 	async_upnp_client==0.38.0
-python_requires = >=3.8
+python_requires = >=3.11
 package_dir = 
 	=src
 zip_safe = no

python_linkplay-0.0.2/src/linkplay/__version__.py

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

{python_linkplay-0.0.0 → python_linkplay-0.0.2}/src/linkplay/bridge.py

@@ -1,5 +1,4 @@
 from __future__ import annotations
-from typing import Dict, List
 
 from aiohttp import ClientSession
 
@@ -11,11 +10,12 @@ from linkplay.consts import (
     MuteMode,
     EqualizerMode,
     LoopMode,
-    PlaybackMode,
-    PLAYBACK_MODE_MAP,
+    PLAY_MODE_SEND_MAP,
     PlayingStatus,
-    PlaymodeSupport,
-    SpeakerType
+    InputMode,
+    SpeakerType,
+    PlayingMode,
+    INPUT_MODE_MAP
 )
 from linkplay.utils import session_call_api_json, session_call_api_ok, decode_hexstr
 
@@ -24,7 +24,7 @@ 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
@@ -33,7 +33,7 @@ class LinkPlayDevice():
         """Update the device status."""
         self.properties = await self.bridge.json_request(LinkPlayCommand.DEVICE_STATUS)  # type: ignore[assignment]
 
-    async def reboot(self):
+    async def reboot(self) -> None:
         """Reboot the device."""
         await self.bridge.request(LinkPlayCommand.REBOOT)
 
@@ -48,9 +48,11 @@ class LinkPlayDevice():
         return self.properties[DeviceAttribute.DEVICE_NAME]
 
     @property
-    def playmode_support(self) -> PlaymodeSupport:
+    def playmode_support(self) -> list[PlayingMode]:
         """Returns the player playmode support."""
-        return PlaymodeSupport(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:
@@ -62,79 +64,75 @@ 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
 
-    async def update_status(self):
+    async def update_status(self) -> None:
         """Update the player status."""
         self.properties = await self.bridge.json_request(LinkPlayCommand.PLAYER_STATUS)  # type: ignore[assignment]
         self.properties[PlayerAttribute.TITLE] = decode_hexstr(self.title)
         self.properties[PlayerAttribute.ARTIST] = decode_hexstr(self.artist)
         self.properties[PlayerAttribute.ALBUM] = decode_hexstr(self.album)
 
-    async def next(self):
+    async def next(self) -> None:
         """Play the next song in the playlist."""
         await self.bridge.request(LinkPlayCommand.NEXT)
 
-    async def previous(self):
+    async def previous(self) -> None:
         """Play the previous song in the playlist."""
         await self.bridge.request(LinkPlayCommand.PREVIOUS)
 
-    async def play(self, value: str):
+    async def play(self, value: str) -> None:
         """Start playing the selected track."""
         await self.bridge.request(LinkPlayCommand.PLAY.format(value))  # type: ignore[str-format]
 
-    async def resume(self):
+    async def resume(self) -> None:
         """Resume playing the current track."""
         await self.bridge.request(LinkPlayCommand.RESUME)
 
-    async def mute(self):
+    async def mute(self) -> None:
         """Mute the player."""
         await self.bridge.request(LinkPlayCommand.MUTE)
         self.properties[PlayerAttribute.MUTED] = MuteMode.MUTED
 
-    async def unmute(self):
+    async def unmute(self) -> None:
         """Unmute the player."""
         await self.bridge.request(LinkPlayCommand.UNMUTE)
         self.properties[PlayerAttribute.MUTED] = MuteMode.UNMUTED
 
-    async def play_playlist(self, index: int):
+    async def play_playlist(self, index: int) -> None:
         """Start playing chosen playlist by index number."""
         await self.bridge.request(LinkPlayCommand.PLAYLIST.format(index))  # type: ignore[str-format]
 
-    async def pause(self):
+    async def pause(self) -> None:
         """Pause the current playing track."""
         await self.bridge.request(LinkPlayCommand.PAUSE)
         self.properties[PlayerAttribute.PLAYING_STATUS] = PlayingStatus.PAUSED
 
-    async def toggle(self):
+    async def toggle(self) -> None:
         """Start playing if the player is currently not playing. Stops playing if it is."""
         await self.bridge.request(LinkPlayCommand.TOGGLE)
 
-    async def set_volume(self, value: int):
+    async def set_volume(self, value: int) -> None:
         """Set the player volume."""
         if not 0 <= value <= 100:
             raise ValueError("Volume must be between 0 and 100.")
 
         await self.bridge.request(LinkPlayCommand.VOLUME.format(value))  # type: ignore[str-format]
-        self.properties[PlayerAttribute.VOLUME] = str(value)
 
-    async def set_equalizer_mode(self, mode: EqualizerMode):
+    async def set_equalizer_mode(self, mode: EqualizerMode) -> None:
         """Set the equalizer mode."""
         await self.bridge.request(LinkPlayCommand.EQUALIZER_MODE.format(mode))  # type: ignore[str-format]
-        self.properties[PlayerAttribute.EQUALIZER_MODE] = mode
 
-    async def set_loop_mode(self, mode: LoopMode):
+    async def set_loop_mode(self, mode: LoopMode) -> None:
         """Set the loop mode."""
         await self.bridge.request(LinkPlayCommand.LOOP_MODE.format(mode))  # type: ignore[str-format]
-        self.properties[PlayerAttribute.PLAYLIST_MODE] = mode
 
-    async def set_play_mode(self, mode: PlaybackMode):
+    async def set_play_mode(self, mode: PlayingMode) -> None:
         """Set the play mode."""
-        await self.bridge.request(LinkPlayCommand.SWITCH_MODE.format(PLAYBACK_MODE_MAP[mode]))  # type: ignore[str-format]
-        self.properties[PlayerAttribute.PLAYBACK_MODE] = mode
+        await self.bridge.request(LinkPlayCommand.SWITCH_MODE.format(PLAY_MODE_SEND_MAP[mode]))  # type: ignore[str-format]
 
     @property
     def muted(self) -> bool:
@@ -192,9 +190,9 @@ class LinkPlayPlayer():
         return ChannelType(self.properties[PlayerAttribute.CHANNEL_TYPE])
 
     @property
-    def playback_mode(self) -> PlaybackMode:
-        """Returns the channel the player is playing on."""
-        return PlaybackMode(self.properties[PlayerAttribute.PLAYBACK_MODE])
+    def play_mode(self) -> PlayingMode:
+        """Returns the current playing mode of the player."""
+        return PlayingMode(self.properties[PlayerAttribute.PLAYBACK_MODE])
 
     @property
     def loop_mode(self) -> LoopMode:
@@ -229,7 +227,7 @@ class LinkPlayBridge():
         """Returns the current player endpoint."""
         return f"{self.protocol}://{self.ip_address}"
 
-    async def json_request(self, command: str) -> Dict[str, str]:
+    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)
 
@@ -243,28 +241,28 @@ class LinkPlayMultiroom():
     The leader is the device that controls the group."""
 
     leader: LinkPlayBridge
-    followers: List[LinkPlayBridge]
+    followers: list[LinkPlayBridge]
 
-    def __init__(self, leader: LinkPlayBridge, followers: List[LinkPlayBridge]):
+    def __init__(self, leader: LinkPlayBridge, followers: list[LinkPlayBridge]):
         self.leader = leader
         self.followers = followers
 
-    async def ungroup(self):
+    async def ungroup(self) -> None:
         """Ungroups the multiroom group."""
         await self.leader.request(LinkPlayCommand.MULTIROOM_UNGROUP)
         self.followers = []
 
-    async def add_follower(self, follower: LinkPlayBridge):
+    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]
         self.followers.append(follower)
 
-    async def remove_follower(self, follower: LinkPlayBridge):
+    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]
         self.followers.remove(follower)
 
-    async def set_volume(self, value: int):
+    async def set_volume(self, value: int) -> None:
         """Sets the volume for the multiroom group."""
         assert 0 < value <= 100
         str_vol = str(value)
@@ -273,10 +271,10 @@ class LinkPlayMultiroom():
         for bridge in [self.leader] + self.followers:
             bridge.player.properties[PlayerAttribute.VOLUME] = str_vol
 
-    async def mute(self):
+    async def mute(self) -> None:
         """Mutes the multiroom group."""
         await self.leader.request(LinkPlayCommand.MULTIROOM_MUTE)
 
-    async def unmute(self):
+    async def unmute(self) -> None:
         """Unmutes the multiroom group."""
         await self.leader.request(LinkPlayCommand.MULTIROOM_UNMUTE)

{python_linkplay-0.0.0 → python_linkplay-0.0.2}/src/linkplay/consts.py

@@ -1,5 +1,4 @@
 from enum import StrEnum, IntFlag
-from typing import Dict
 
 API_ENDPOINT: str = "{}/httpapi.asp?command={}"
 API_TIMEOUT: int = 2
@@ -51,8 +50,8 @@ class ChannelType(StrEnum):
     RIGHT_CHANNEL = "2"
 
 
-class PlaybackMode(StrEnum):
-    """Defines the playback mode."""
+class PlayingMode(StrEnum):
+    """Defines a possible playing mode."""
     IDLE = "-1"
     NONE = "0"
     AIRPLAY = "1"
@@ -75,7 +74,7 @@ class PlaybackMode(StrEnum):
     EXT_LOCAL = "42"
     OPTICAL = "43"
     RCA = "44"
-    CO_AXIAL = "45"
+    COAXIAL = "45"
     FM = "46"
     LINE_IN_2 = "47"
     XLR = "48"
@@ -83,37 +82,39 @@ class PlaybackMode(StrEnum):
     MIRROR = "50"
     USB_DAC = "51"
     TF_CARD_2 = "52"
+    OPTICAL_2 = "56"
     TALK = "60"
     SLAVE = "99"
 
 
-PLAYBACK_MODE_MAP: Dict[PlaybackMode, str] = {
-    PlaybackMode.IDLE: 'Idle',
-    PlaybackMode.NONE: 'Idle',
-    PlaybackMode.AIRPLAY: 'Airplay',
-    PlaybackMode.DLNA: 'DLNA',
-    PlaybackMode.QPLAY: 'QPlay',
-    PlaybackMode.NETWORK: 'wifi',
-    PlaybackMode.WIIMU_LOCAL: 'udisk',
-    PlaybackMode.TF_CARD_1: 'TFcard',
-    PlaybackMode.API: 'API',
-    PlaybackMode.UDISK: 'udisk',
-    PlaybackMode.ALARM: 'Alarm',
-    PlaybackMode.SPOTIFY: 'Spotify',
-    PlaybackMode.LINE_IN: 'line-in',
-    PlaybackMode.BLUETOOTH: 'bluetooth',
-    PlaybackMode.OPTICAL: 'optical',
-    PlaybackMode.RCA: 'RCA',
-    PlaybackMode.CO_AXIAL: 'co-axial',
-    PlaybackMode.FM: 'FM',
-    PlaybackMode.LINE_IN_2: 'line-in2',
-    PlaybackMode.XLR: 'XLR',
-    PlaybackMode.HDMI: 'HDMI',
-    PlaybackMode.MIRROR: 'cd',
-    PlaybackMode.USB_DAC: 'USB DAC',
-    PlaybackMode.TF_CARD_2: 'TFcard',
-    PlaybackMode.TALK: 'Talk',
-    PlaybackMode.SLAVE: 'Idle'
+# 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'
 }
 
 
@@ -124,6 +125,7 @@ class LoopMode(StrEnum):
     CONTINUOUS_PLAYBACK = "1"
     RANDOM_PLAYBACK = "2"
     LIST_CYCLE = "3"
+    FOUR = "4"
 
 
 class EqualizerMode(StrEnum):
@@ -149,18 +151,31 @@ class MuteMode(StrEnum):
     MUTED = "1"
 
 
-class PlaymodeSupport(IntFlag):
-    """Defines which modes the player supports."""
+class InputMode(IntFlag):
+    """Defines which inputs the player supports."""
     LINE_IN = 2
     BLUETOOTH = 4
     USB = 8
     OPTICAL = 16
     COAXIAL = 64
     LINE_IN_2 = 256
-    USBDAC = 32768
+    USB_DAC = 32768
     OPTICAL_2 = 262144
 
 
+# Map between the input modes and the play mode
+INPUT_MODE_MAP: dict[InputMode, PlayingMode] = {
+    InputMode.LINE_IN: PlayingMode.LINE_IN,
+    InputMode.BLUETOOTH: PlayingMode.BLUETOOTH,
+    InputMode.USB: PlayingMode.UDISK,
+    InputMode.OPTICAL: PlayingMode.OPTICAL,
+    InputMode.COAXIAL: PlayingMode.COAXIAL,
+    InputMode.LINE_IN_2: PlayingMode.LINE_IN_2,
+    InputMode.USB_DAC: PlayingMode.USB_DAC,
+    InputMode.OPTICAL_2: PlayingMode.OPTICAL_2
+}
+
+
 class PlayerAttribute(StrEnum):
     """Defines the player attributes."""
     SPEAKER_TYPE = "type"
@@ -270,3 +285,4 @@ class MultiroomAttribute(StrEnum):
     NUM_FOLLOWERS = "slaves"
     FOLLOWER_LIST = "slave_list"
     UUID = "uuid"
+    IP = "ip"

python_linkplay-0.0.2/src/linkplay/discovery.py

@@ -0,0 +1,86 @@
+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, LinkPlayMultiroom
+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) -> 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
+    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_multirooms(bridges: list[LinkPlayBridge]) -> list[LinkPlayMultiroom]:
+    """Discovers multirooms through the list of provided bridges."""
+    multirooms: list[LinkPlayMultiroom] = []
+    bridges_dict: dict[str, LinkPlayBridge] = {bridge.device.uuid: bridge for bridge in bridges}
+
+    for bridge in bridges:
+        properties: dict[Any, Any] = await bridge.json_request(LinkPlayCommand.MULTIROOM_LIST)
+
+        if int(properties[MultiroomAttribute.NUM_FOLLOWERS]) == 0:
+            continue
+
+        followers: list[LinkPlayBridge] = []
+        for follower in properties[MultiroomAttribute.FOLLOWER_LIST]:
+            if follower[MultiroomAttribute.UUID] in bridges_dict:
+                followers.append(bridges_dict[follower[MultiroomAttribute.UUID]])
+
+        multirooms.append(LinkPlayMultiroom(bridge, followers))
+
+    return multirooms
+
+
+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.0 → python_linkplay-0.0.2}/src/linkplay/utils.py

@@ -10,7 +10,7 @@ from linkplay.consts import API_ENDPOINT, API_TIMEOUT
 from linkplay.exceptions import LinkPlayRequestException
 
 
-async def session_call_api(endpoint: str, session: ClientSession, command: str):
+async def session_call_api(endpoint: str, session: ClientSession, command: str) -> str:
     """Calls the LinkPlay API and returns the result as a string.
 
     Args:
@@ -46,7 +46,7 @@ async def session_call_api_json(endpoint: str, session: ClientSession,
     return json.loads(result)  # type: ignore
 
 
-async def session_call_api_ok(endpoint: str, session: ClientSession, command: str):
+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)
 
@@ -56,4 +56,7 @@ async def session_call_api_ok(endpoint: str, session: ClientSession, command: st
 
 def decode_hexstr(hexstr: str) -> str:
     """Decode a hex string."""
-    return bytes.fromhex(hexstr).decode("utf-8")
+    try:
+        return bytes.fromhex(hexstr).decode("utf-8")
+    except ValueError:
+        return hexstr

{python_linkplay-0.0.0 → python_linkplay-0.0.2/src/python_linkplay.egg-info}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: python_linkplay
-Version: 0.0.0
+Version: 0.0.2
 Summary: A Python Library for Seamless LinkPlay Device Control
 Author: Velleman Group nv
 License: MIT
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: async-timeout==4.0.3
@@ -23,8 +23,7 @@ Requires-Dist: typing-extensions>=4.6.3; extra == "testing"
 
 
 [![PyPI package](https://badge.fury.io/py/python-linkplay.svg)](https://pypi.org/project/python-linkplay/)
-
-[![Release](https://github.com/velleman/python-linkplay/actions/workflows/release/badge.svg)](https://github.com/velleman/python-linkplay/actions/workflows/release.yaml)
+[![Release](https://github.com/velleman/python-linkplay/actions/workflows/release.yaml/badge.svg)](https://github.com/velleman/python-linkplay/actions/workflows/release.yaml)
 
 # python-linkplay
 A Python Library for Seamless LinkPlay Device Control

python_linkplay-0.0.0/src/linkplay/__version__.py

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

python_linkplay-0.0.0/src/linkplay/discovery.py

@@ -1,63 +0,0 @@
-from typing import Any, Dict, List
-
-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, LinkPlayMultiroom
-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) -> List[LinkPlayBridge]:
-    """Attempts to discover LinkPlay devices on the local network."""
-    devices: List[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):
-            devices.append(bridge)
-
-    await async_search(
-        search_target=UPNP_DEVICE_TYPE,
-        async_callback=add_linkplay_device_to_list
-    )
-
-    return devices
-
-
-async def discover_multirooms(bridges: List[LinkPlayBridge]) -> List[LinkPlayMultiroom]:
-    """Discovers multirooms through the list of provided bridges."""
-    multirooms: List[LinkPlayMultiroom] = []
-
-    for bridge in bridges:
-        properties: Dict[Any, Any] = await bridge.json_request(LinkPlayCommand.MULTIROOM_LIST)
-
-        if int(properties[MultiroomAttribute.NUM_FOLLOWERS]) == 0:
-            continue
-
-        followers: List[LinkPlayBridge] = []
-        for follower in properties[MultiroomAttribute.FOLLOWER_LIST]:
-            follower_uuid = follower[MultiroomAttribute.UUID]
-            if follower_bridge := next((b for b in bridges if b.device.uuid == follower_uuid), None):
-                followers.append(follower_bridge)
-
-        multirooms.append(LinkPlayMultiroom(bridge, followers))
-
-    return multirooms