python-linkplay 0.0.6__tar.gz → 0.0.8__tar.gz

{python_linkplay-0.0.6/src/python_linkplay.egg-info → python_linkplay-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python_linkplay
-Version: 0.0.6
+Version: 0.0.8
 Summary: A Python Library for Seamless LinkPlay Device Control
 Author: Velleman Group nv
 License: MIT
@@ -10,7 +10,10 @@ 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
+Requires-Dist: aiofiles>=24.1.0
 Provides-Extra: testing
 Requires-Dist: pytest>=7.3.1; extra == "testing"
 Requires-Dist: pytest-cov>=4.1.0; extra == "testing"
@@ -20,6 +23,7 @@ Requires-Dist: mypy>=1.3.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.6 → python_linkplay-0.0.8}/pyproject.toml

@@ -27,5 +27,5 @@ warn_unreachable = true
 warn_unused_configs = true
 no_implicit_reexport = true
 
-[tool.ruff.lint.extend-per-file-ignores]
-"__init__.py" = ["F401"]
+[tool.ruff.lint]
+select = ["I"]

{python_linkplay-0.0.6 → python_linkplay-0.0.8}/setup.cfg

@@ -14,7 +14,10 @@ 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
+	aiofiles>=24.1.0
 python_requires = >=3.11
 package_dir = 
 	=src
@@ -36,6 +39,7 @@ testing =
 	ruff>=0.5.4
 	tox>=4.6.0
 	typing-extensions>=4.6.3
+	pre-commit>=3.8.0
 
 [egg_info]
 tag_build = 

{python_linkplay-0.0.6 → python_linkplay-0.0.8}/src/linkplay/__main__.py

@@ -1,11 +1,11 @@
 import asyncio
-import aiohttp
 
 from linkplay.controller import LinkPlayController
+from linkplay.utils import async_create_unverified_client_session
 
 
 async def main():
-    async with aiohttp.ClientSession() as session:
+    async with await async_create_unverified_client_session() as session:
         controller = LinkPlayController(session)
 
         await controller.discover_bridges()

python_linkplay-0.0.8/src/linkplay/__version__.py

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

{python_linkplay-0.0.6 → python_linkplay-0.0.8}/src/linkplay/bridge.py

@@ -1,25 +1,25 @@
 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:
@@ -44,12 +44,12 @@ 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]:
@@ -63,7 +63,11 @@ class LinkPlayDevice:
     @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:
@@ -147,103 +151,94 @@ class LinkPlayPlayer:
     @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:
     """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:

{python_linkplay-0.0.6 → python_linkplay-0.0.8}/src/linkplay/consts.py

@@ -1,19 +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"
 
+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"
@@ -56,6 +109,7 @@ class ChannelType(StrEnum):
 class PlayingMode(StrEnum):
     """Defines a possible playing mode."""
 
+    DAB = "-96"  # Unmapped
     IDLE = "-1"
     NONE = "0"
     AIRPLAY = "1"
@@ -75,7 +129,6 @@ class PlayingMode(StrEnum):
     SPOTIFY = "31"
     LINE_IN = "40"
     BLUETOOTH = "41"
-    EXT_LOCAL = "42"
     OPTICAL = "43"
     RCA = "44"
     COAXIAL = "45"
@@ -83,12 +136,16 @@ 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
@@ -113,12 +170,17 @@ PLAY_MODE_SEND_MAP: dict[PlayingMode, str] = {  # case sensitive!
     PlayingMode.LINE_IN_2: "line-in2",
     PlayingMode.XLR: "XLR",
     PlayingMode.HDMI: "HDMI",
-    PlayingMode.MIRROR: "cd",
-    PlayingMode.USB_DAC: "USB DAC",
+    PlayingMode.CD: "cd",
+    PlayingMode.USB_DAC: "PCUSB",
     PlayingMode.TF_CARD_2: "TFcard",
     PlayingMode.TALK: "Talk",
-    PlayingMode.SLAVE: "Idle",
+    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",
 }
 
 
@@ -167,10 +229,21 @@ class InputMode(IntFlag):
     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
@@ -179,10 +252,21 @@ 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.PHONO: PlayingMode.PHONO,
     InputMode.OPTICAL_2: PlayingMode.OPTICAL_2,
+    InputMode.COAXIAL_2: PlayingMode.COAXIAL_2,
+    InputMode.FOLLOWER: PlayingMode.FOLLOWER,
+    InputMode.ARC: PlayingMode.ARC,
 }
 
 
@@ -290,6 +374,30 @@ 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):

{python_linkplay-0.0.6 → python_linkplay-0.0.8}/src/linkplay/discovery.py

@@ -3,26 +3,63 @@ 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.consts import UPNP_DEVICE_TYPE, LinkPlayCommand, MultiroomAttribute
 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."""
-    bridge = LinkPlayBridge("http", ip_address, session)
+    endpoint: LinkPlayApiEndpoint = LinkPlayApiEndpoint(
+        protocol="http", endpoint=ip_address, session=session
+    )
     try:
-        await bridge.device.update_status()
-        await bridge.player.update_status()
+        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]:
@@ -35,8 +72,11 @@ async def discover_linkplay_bridges(
         if not ip_address:
             return
 
-        if bridge := await linkplay_factory_bridge(ip_address, session):
+        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
@@ -67,9 +107,12 @@ async def discover_bridges_through_multiroom(
 
     followers: list[LinkPlayBridge] = []
     for follower in properties[MultiroomAttribute.FOLLOWER_LIST]:
-        if new_bridge := await linkplay_factory_bridge(
-            follower[MultiroomAttribute.IP], session
-        ):
+        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.8/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.8/src/linkplay/utils.py

@@ -0,0 +1,127 @@
+import asyncio
+import contextlib
+import json
+import os
+import socket
+import ssl
+from http import HTTPStatus
+from typing import Dict
+
+import aiofiles
+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)
+
+    return create_ssl_context(path=mtls_certificate_path)
+
+
+async def async_create_unverified_context() -> ssl.SSLContext:
+    """Asynchronously creates an unverified SSL context with the default mTLS certificate."""
+    async with aiofiles.tempfile.NamedTemporaryFile(
+        "w", encoding="utf-8"
+    ) as mtls_certificate:
+        await mtls_certificate.write(MTLS_CERTIFICATE_CONTENTS)
+        await mtls_certificate.flush()
+        return create_ssl_context(path=str(mtls_certificate.name))
+
+
+def create_ssl_context(path: str) -> ssl.SSLContext:
+    """Creates an SSL context from given certificate file."""
+    sslcontext: ssl.SSLContext = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    sslcontext.check_hostname = False
+    sslcontext.verify_mode = ssl.CERT_NONE
+    sslcontext.load_cert_chain(certfile=path)
+    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)
+
+
+async def async_create_unverified_client_session() -> ClientSession:
+    """Asynchronously creates a ClientSession using the default unverified SSL context"""
+    context: ssl.SSLContext = await async_create_unverified_context()
+    connector: TCPConnector = TCPConnector(family=socket.AF_UNSPEC, ssl=context)
+    return ClientSession(connector=connector)

{python_linkplay-0.0.6 → python_linkplay-0.0.8/src/python_linkplay.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python_linkplay
-Version: 0.0.6
+Version: 0.0.8
 Summary: A Python Library for Seamless LinkPlay Device Control
 Author: Velleman Group nv
 License: MIT
@@ -10,7 +10,10 @@ 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
+Requires-Dist: aiofiles>=24.1.0
 Provides-Extra: testing
 Requires-Dist: pytest>=7.3.1; extra == "testing"
 Requires-Dist: pytest-cov>=4.1.0; extra == "testing"
@@ -20,6 +23,7 @@ Requires-Dist: mypy>=1.3.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.6 → python_linkplay-0.0.8}/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.6 → python_linkplay-0.0.8}/src/python_linkplay.egg-info/requires.txt

@@ -1,6 +1,9 @@
 async-timeout>=4.0.3
 aiohttp>=3.8.5
+appdirs>=1.4.4
 async_upnp_client>=0.36.2
+deprecated>=1.2.14
+aiofiles>=24.1.0
 
 [testing]
 pytest>=7.3.1
@@ -11,3 +14,4 @@ mypy>=1.3.0
 ruff>=0.5.4
 tox>=4.6.0
 typing-extensions>=4.6.3
+pre-commit>=3.8.0

python_linkplay-0.0.6/src/linkplay/__version__.py

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

python_linkplay-0.0.6/src/linkplay/utils.py

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