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

{python_linkplay-0.0.8 → python_linkplay-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python_linkplay
-Version: 0.0.8
+Version: 0.0.9
 Summary: A Python Library for Seamless LinkPlay Device Control
 Author: Velleman Group nv
 License: MIT

{python_linkplay-0.0.8 → python_linkplay-0.0.9}/setup.py

@@ -1,5 +1,4 @@
 from setuptools import setup
 
-
 if __name__ == "__main__":
     setup()

python_linkplay-0.0.9/src/linkplay/__version__.py

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

{python_linkplay-0.0.8 → python_linkplay-0.0.9}/src/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]
 

{python_linkplay-0.0.8 → python_linkplay-0.0.9}/src/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):

{python_linkplay-0.0.8 → python_linkplay-0.0.9}/src/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)

{python_linkplay-0.0.8 → python_linkplay-0.0.9}/src/linkplay/utils.py

@@ -1,20 +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.
@@ -51,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
@@ -67,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:
@@ -75,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")
@@ -90,16 +140,38 @@ def create_unverified_context() -> ssl.SSLContext:
     return create_ssl_context(path=mtls_certificate_path)
 
 
-async def async_create_unverified_context() -> ssl.SSLContext:
+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()
-        return create_ssl_context(path=str(mtls_certificate.name))
+        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
+    sslcontext.set_default_verify_paths()
+    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)
@@ -113,6 +185,9 @@ def create_ssl_context(path: str) -> ssl.SSLContext:
     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()
@@ -125,3 +200,27 @@ async def async_create_unverified_client_session() -> ClientSession:
     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.8 → python_linkplay-0.0.9}/src/python_linkplay.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python_linkplay
-Version: 0.0.8
+Version: 0.0.9
 Summary: A Python Library for Seamless LinkPlay Device Control
 Author: Velleman Group nv
 License: MIT

python_linkplay-0.0.8/src/linkplay/__version__.py

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