python-linkplay 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

linkplay/__main__.py

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

linkplay/__version__.py

@@ -1 +1 @@
-__version__ = '0.0.7'
+__version__ = '0.0.9'

linkplay/bridge.py

@@ -19,7 +19,7 @@ from linkplay.consts import (
     SpeakerType,
 )
 from linkplay.endpoint import LinkPlayEndpoint
-from linkplay.utils import decode_hexstr
+from linkplay.utils import fixup_player_properties
 
 
 class LinkPlayDevice:
@@ -83,10 +83,11 @@ class LinkPlayPlayer:
 
     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)
+        properties: dict[PlayerAttribute, str] = await self.bridge.json_request(
+            LinkPlayCommand.PLAYER_STATUS
+        )  # type: ignore[assignment]
+
+        self.properties = fixup_player_properties(properties)
 
     async def next(self) -> None:
         """Play the next song in the playlist."""
@@ -148,10 +149,19 @@ class LinkPlayPlayer:
             LinkPlayCommand.SWITCH_MODE.format(PLAY_MODE_SEND_MAP[mode])
         )  # type: ignore[str-format]
 
+    async def play_preset(self, preset_number: int) -> None:
+        """Play a preset."""
+        if not 0 < preset_number <= 10:
+            raise ValueError("Preset must be between 1 and 10.")
+        await self.bridge.request(LinkPlayCommand.PLAY_PRESET.format(preset_number))
+
     @property
     def muted(self) -> bool:
         """Returns if the player is muted."""
-        return self.properties.get(PlayerAttribute.MUTED, MuteMode.UNMUTED) == MuteMode.MUTED
+        return (
+            self.properties.get(PlayerAttribute.MUTED, MuteMode.UNMUTED)
+            == MuteMode.MUTED
+        )
 
     @property
     def title(self) -> str:
@@ -186,32 +196,46 @@ class LinkPlayPlayer:
     @property
     def status(self) -> PlayingStatus:
         """Returns the current playing status."""
-        return PlayingStatus(self.properties.get(PlayerAttribute.PLAYING_STATUS, PlayingStatus.STOPPED))
+        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.get(PlayerAttribute.EQUALIZER_MODE, EqualizerMode.CLASSIC))
+        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.get(PlayerAttribute.SPEAKER_TYPE, SpeakerType.MAIN_SPEAKER))
+        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.get(PlayerAttribute.CHANNEL_TYPE, ChannelType.STEREO))
+        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.get(PlayerAttribute.PLAYBACK_MODE, PlayingMode.IDLE))
+        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.get(PlayerAttribute.PLAYLIST_MODE, LoopMode.CONTINUOUS_PLAYBACK))
+        return LoopMode(
+            self.properties.get(
+                PlayerAttribute.PLAYLIST_MODE, LoopMode.CONTINUOUS_PLAYBACK
+            )
+        )
 
 
 class LinkPlayBridge:
@@ -292,7 +316,9 @@ class LinkPlayMultiroom:
 
     async def set_volume(self, value: int) -> None:
         """Sets the volume for the multiroom group."""
-        assert 0 < value <= 100
+        if not 0 <= value <= 100:
+            raise ValueError("Volume must be between 0 and 100")
+
         str_vol = str(value)
         await self.leader.request(LinkPlayCommand.MULTIROOM_VOL.format(str_vol))  # type: ignore[str-format]
 

linkplay/consts.py

@@ -4,6 +4,8 @@ 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"
+TCPPORT = 8899
+TCP_MESSAGE_LENGTH = 1024
 
 MTLS_CERTIFICATE_CONTENTS = """
 -----BEGIN PRIVATE KEY-----
@@ -89,6 +91,17 @@ class LinkPlayCommand(StrEnum):
     MULTIROOM_MUTE = "setPlayerCmd:slave_mute:mute"
     MULTIROOM_UNMUTE = "setPlayerCmd:slave_mute:unmute"
     MULTIROOM_JOIN = "ConnectMasterAp:JoinGroupMaster:eth{}:wifi0.0.0.0"
+    PLAY_PRESET = "MCUKeyShortClick:{}"
+
+
+class LinkPlayTcpUartCommand(StrEnum):
+    """Defined LinkPlay TCPUART commands."""
+
+    GET_METADATA = "MCU+MEA+GET"
+    PRESET_PLAY = "MCU+KEY+{:03}"
+    PRESET_NEXT = "MCU+KEY+NXT"
+    INPUT_WIFI = "MCU+PLM+000"
+    INPUT_BLUETOOTH = "MCU+PLM+006"
 
 
 class SpeakerType(StrEnum):

linkplay/endpoint.py

@@ -1,8 +1,15 @@
+import asyncio
 from abc import ABC, abstractmethod
 
 from aiohttp import ClientSession
 
-from linkplay.utils import session_call_api_json, session_call_api_ok
+from linkplay.consts import TCPPORT
+from linkplay.utils import (
+    call_tcpuart,
+    call_tcpuart_json,
+    session_call_api_json,
+    session_call_api_ok,
+)
 
 
 class LinkPlayEndpoint(ABC):
@@ -38,3 +45,20 @@ class LinkPlayApiEndpoint(LinkPlayEndpoint):
 
     def __str__(self) -> str:
         return self._endpoint
+
+
+class LinkPlayTcpUartEndpoint(LinkPlayEndpoint):
+    """Represents a LinkPlay TCPUART API endpoint."""
+
+    def __init__(
+        self, *, connection: tuple[asyncio.StreamReader, asyncio.StreamWriter]
+    ):
+        self._connection = connection
+
+    async def request(self, command: str) -> None:
+        reader, writer = self._connection
+        await call_tcpuart(reader, writer, command)
+
+    async def json_request(self, command: str) -> dict[str, str]:
+        reader, writer = self._connection
+        return await call_tcpuart_json(reader, writer, command)

linkplay/utils.py

@@ -1,19 +1,31 @@
 import asyncio
 import contextlib
 import json
+import logging
 import os
 import socket
 import ssl
+from concurrent.futures import ThreadPoolExecutor
 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 deprecated import deprecated
+
+from linkplay.consts import (
+    API_ENDPOINT,
+    API_TIMEOUT,
+    MTLS_CERTIFICATE_CONTENTS,
+    TCP_MESSAGE_LENGTH,
+    PlayerAttribute,
+    PlayingStatus,
+)
 from linkplay.exceptions import LinkPlayRequestException
 
+_LOGGER = logging.getLogger(__name__)
+
 
 async def session_call_api(endpoint: str, session: ClientSession, command: str) -> str:
     """Calls the LinkPlay API and returns the result as a string.
@@ -50,7 +62,7 @@ async def session_call_api(endpoint: str, session: ClientSession, command: str)
 
 async def session_call_api_json(
     endpoint: str, session: ClientSession, command: str
-) -> Dict[str, 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
@@ -66,6 +78,44 @@ async def session_call_api_ok(
         raise LinkPlayRequestException(f"Didn't receive expected OK from {endpoint}")
 
 
+async def call_tcpuart(
+    reader: asyncio.StreamReader, writer: asyncio.StreamWriter, cmd: str
+) -> str:
+    """Get the latest data from TCP UART service."""
+    payload_header: str = "18 96 18 20 "
+    payload_length: str = format(len(cmd), "02x")
+    payload_command_header: str = " 00 00 00 c1 02 00 00 00 00 00 00 00 00 00 00 "
+    payload_command_content: str = " ".join(hex(ord(c))[2:] for c in cmd)
+
+    async with async_timeout.timeout(API_TIMEOUT):
+        writer.write(
+            bytes.fromhex(
+                payload_header
+                + payload_length
+                + payload_command_header
+                + payload_command_content
+            )
+        )
+
+        data: bytes = await reader.read(TCP_MESSAGE_LENGTH)
+
+        if data == b"":
+            raise LinkPlayRequestException("No data received from socket")
+
+        return str(repr(data))
+
+
+async def call_tcpuart_json(
+    reader: asyncio.StreamReader, writer: asyncio.StreamWriter, cmd: str
+) -> dict[str, str]:
+    """Get JSON data from TCPUART service."""
+    raw_response: str = await call_tcpuart(reader, writer, cmd)
+    strip_start = raw_response.find("{")
+    strip_end = raw_response.find("}", strip_start) + 1
+    data = raw_response[strip_start:strip_end]
+    return json.loads(data)  # type: ignore
+
+
 def decode_hexstr(hexstr: str) -> str:
     """Decode a hex string."""
     try:
@@ -74,6 +124,7 @@ def decode_hexstr(hexstr: str) -> str:
         return hexstr
 
 
+@deprecated(version="0.0.9", reason="Use async_create_unverified_context instead")
 def create_unverified_context() -> ssl.SSLContext:
     """Creates an unverified SSL context with the default mTLS certificate."""
     dirs = AppDirs("python-linkplay")
@@ -86,12 +137,33 @@ def create_unverified_context() -> ssl.SSLContext:
         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)
+    return create_ssl_context(path=mtls_certificate_path)
+
+
+async def async_create_unverified_context(
+    executor: ThreadPoolExecutor | None = None,
+) -> 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()
+        certfile: str = str(mtls_certificate.name)
+        return await async_create_ssl_context(certfile=certfile, executor=executor)
+
+
+async def async_create_ssl_context(
+    *, certfile: str, executor: ThreadPoolExecutor | None = None
+) -> 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
+
+    loop = asyncio.get_running_loop()
+    await loop.run_in_executor(executor, sslcontext.load_cert_chain, certfile)
+
     with contextlib.suppress(AttributeError):
         # This only works for OpenSSL >= 1.0.0
         sslcontext.options |= ssl.OP_NO_COMPRESSION
@@ -99,8 +171,56 @@ def create_unverified_context() -> ssl.SSLContext:
     return sslcontext
 
 
+@deprecated(version="0.0.9", reason="Use async_create_ssl_context instead")
+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
+
+
+@deprecated(
+    version="0.0.9", reason="Use async_create_unverified_client_session instead"
+)
 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)
+
+
+def fixup_player_properties(
+    properties: dict[PlayerAttribute, str],
+) -> dict[PlayerAttribute, str]:
+    """Fixes up PlayerAttribute in a dict."""
+    properties[PlayerAttribute.TITLE] = decode_hexstr(
+        properties.get(PlayerAttribute.TITLE, "")
+    )
+    properties[PlayerAttribute.ARTIST] = decode_hexstr(
+        properties.get(PlayerAttribute.ARTIST, "")
+    )
+    properties[PlayerAttribute.ALBUM] = decode_hexstr(
+        properties.get(PlayerAttribute.ALBUM, "")
+    )
+
+    # Fixup playing status "none" by setting it to "stopped"
+    if (
+        properties.get(PlayerAttribute.PLAYING_STATUS, "")
+        not in PlayingStatus.__members__.values()
+    ):
+        properties[PlayerAttribute.PLAYING_STATUS] = PlayingStatus.STOPPED
+
+    return properties

{python_linkplay-0.0.7.dist-info → python_linkplay-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python_linkplay
-Version: 0.0.7
+Version: 0.0.9
 Summary: A Python Library for Seamless LinkPlay Device Control
 Author: Velleman Group nv
 License: MIT
@@ -13,6 +13,7 @@ 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"

python_linkplay-0.0.9.dist-info/RECORD

@@ -0,0 +1,15 @@
+linkplay/__init__.py,sha256=y9ZehEq-KhS3cwn-PUpwVSJGfDUx7e5wf_G6guODcTk,56
+linkplay/__main__.py,sha256=Wcza80QaWfOaHjyJEfQYhB9kiPLE0NOqIj4zVWv2Nqs,577
+linkplay/__version__.py,sha256=VkqKNhCu7_SPtm2SJjQ7vIeLd6wBQJZl_t1N5uPUZuc,22
+linkplay/bridge.py,sha256=LXUc1zcRh1Hx1QauhlpA9da5k7f6h3KLfGRA1jAbTPU,11602
+linkplay/consts.py,sha256=OGEj34YTiEWRBPjIebokDOVKOsa-DpZkCkUpThO8IIc,13068
+linkplay/controller.py,sha256=JIQAKPs3EK7ZwzoyzSy0HBl21gH9Cc9RrLXIGOMzkCM,2146
+linkplay/discovery.py,sha256=aEzN_94pKLmHKYIL7DxSW0FYRsaF2ruZe2bwXz0zf5U,4299
+linkplay/endpoint.py,sha256=aWNiiU6h3gIWiNzcnavfA8IMZLufv9A8Cm5qphRpRvA,2158
+linkplay/exceptions.py,sha256=tWJWHsKVkUEq3Yet1Z739IxcaQT8YamDeSp0tqHde9c,107
+linkplay/utils.py,sha256=WVKdxITDymLCmKGqlD9Ieyb96qZ-QSC9oIe-KGW4IFU,7827
+python_linkplay-0.0.9.dist-info/LICENSE,sha256=bgEtxMyjEHX_4uwaAY3GCFTm234D4AOZ5dM15sk26ms,1073
+python_linkplay-0.0.9.dist-info/METADATA,sha256=raTNkO4qPbCWo9MP2B-mugtvVgodiRjQZGFQqud8bIQ,2987
+python_linkplay-0.0.9.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+python_linkplay-0.0.9.dist-info/top_level.txt,sha256=CpSaOVPTzJf5TVIL7MrotSCR34gcIOQy-11l4zGmxxM,9
+python_linkplay-0.0.9.dist-info/RECORD,,

{python_linkplay-0.0.7.dist-info → python_linkplay-0.0.9.dist-info}/WHEEL

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

python_linkplay-0.0.7.dist-info/RECORD

@@ -1,15 +0,0 @@
-linkplay/__init__.py,sha256=y9ZehEq-KhS3cwn-PUpwVSJGfDUx7e5wf_G6guODcTk,56
-linkplay/__main__.py,sha256=rH3diy9W57N1mw16XeTYkymImeSTIWIaBeB2AGzlL28,559
-linkplay/__version__.py,sha256=7EgDv-timUu06OY6bkABnaoin_WSpRfqEKwS3w4SJZ4,22
-linkplay/bridge.py,sha256=KGD-gwJRhDIdE9jAOUyVlcpfGDb1diDUkggTDvVkf-M,11164
-linkplay/consts.py,sha256=wz1lVRz-9hkymc9ucV_LHldcu-msYvimI0tjr2Ncgoc,12734
-linkplay/controller.py,sha256=JIQAKPs3EK7ZwzoyzSy0HBl21gH9Cc9RrLXIGOMzkCM,2146
-linkplay/discovery.py,sha256=aEzN_94pKLmHKYIL7DxSW0FYRsaF2ruZe2bwXz0zf5U,4299
-linkplay/endpoint.py,sha256=qbB977_KltNRZlWlm-3JiByPZiie84Hn2TL523IfqGs,1486
-linkplay/exceptions.py,sha256=tWJWHsKVkUEq3Yet1Z739IxcaQT8YamDeSp0tqHde9c,107
-linkplay/utils.py,sha256=IdUtceKTA3vdY_HNzKUFZzPGXkQFW8E4yUNe5K9TNbo,3583
-python_linkplay-0.0.7.dist-info/LICENSE,sha256=bgEtxMyjEHX_4uwaAY3GCFTm234D4AOZ5dM15sk26ms,1073
-python_linkplay-0.0.7.dist-info/METADATA,sha256=VCLgUHUz00tc0tLzAiOpMkPDeIbrHDfkYrItjH8VZXA,2955
-python_linkplay-0.0.7.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-python_linkplay-0.0.7.dist-info/top_level.txt,sha256=CpSaOVPTzJf5TVIL7MrotSCR34gcIOQy-11l4zGmxxM,9
-python_linkplay-0.0.7.dist-info/RECORD,,