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

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

@@ -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.7 → python_linkplay-0.0.9}/setup.cfg

@@ -17,6 +17,7 @@ install_requires =
 	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

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

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

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

python_linkplay-0.0.9/src/linkplay/__version__.py

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

{python_linkplay-0.0.7 → 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.7 → 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.7 → 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.9/src/linkplay/utils.py

@@ -0,0 +1,226 @@
+import asyncio
+import contextlib
+import json
+import logging
+import os
+import socket
+import ssl
+from concurrent.futures import ThreadPoolExecutor
+from http import HTTPStatus
+
+import aiofiles
+import async_timeout
+from aiohttp import ClientError, ClientSession, TCPConnector
+from appdirs import AppDirs
+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.
+
+    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}")
+
+
+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:
+        return bytes.fromhex(hexstr).decode("utf-8")
+    except ValueError:
+        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")
+    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(
+    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
+    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)
+    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 → 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.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.7 → python_linkplay-0.0.9}/src/python_linkplay.egg-info/requires.txt

@@ -3,6 +3,7 @@ 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

python_linkplay-0.0.7/src/linkplay/__version__.py

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

python_linkplay-0.0.7/src/linkplay/utils.py

@@ -1,106 +0,0 @@
-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)