tinkly 0.2.0__py3-none-any.whl

tinkly/authentication.py

@@ -0,0 +1,67 @@
+"""Cryptographic helpers used by Twinkly authentication."""
+
+from __future__ import annotations
+
+import hashlib
+import itertools
+import re
+
+CHALLENGE_KEY = b'evenmoresecret!!'
+
+
+def mac_bytes(mac: str) -> bytes:
+    """Decode a MAC address into six bytes, ignoring non-hex separators.
+
+    Raises:
+        ValueError: The address does not contain exactly twelve hex digits.
+    """
+    compact = re.sub(r'[^0-9a-fA-F]', '', mac)
+    if len(compact) != 12:
+        raise ValueError(f'MAC address must contain 12 hex digits: {mac!r}')
+    return bytes.fromhex(compact)
+
+
+def xor_repeating(message: bytes, key: bytes) -> bytes:
+    """XOR each message byte with a cycling key and return the resulting bytes.
+
+    An empty key produces an empty result.
+    """
+    return bytes(m ^ k for m, k in zip(message, itertools.cycle(key)))
+
+
+def derive_key(shared_key: bytes, mac: str) -> bytes:
+    """XOR a shared key with the repeating six-byte device MAC address."""
+    return xor_repeating(shared_key, mac_bytes(mac))
+
+
+def rc4(message: bytes, key: bytes) -> bytes:
+    """Apply RC4 to a message using a non-empty key.
+
+    The same operation encrypts and decrypts. This reproduces the cipher used
+    by the device's authentication protocol.
+    """
+    state = list(range(256))
+    j = 0
+    for i in range(256):
+        j = (j + state[i] + key[i % len(key)]) % 256
+        state[i], state[j] = state[j], state[i]
+
+    output = bytearray()
+    i = 0
+    j = 0
+    for b in message:
+        i = (i + 1) % 256
+        j = (j + state[i]) % 256
+        state[i], state[j] = state[j], state[i]
+        output.append(b ^ state[(state[i] + state[j]) % 256])
+    return bytes(output)
+
+
+def make_challenge_response(challenge: bytes, mac: str) -> str:
+    """Return the device authentication response as a SHA-1 hex digest.
+
+    Encrypt the raw challenge with RC4 using the shared key combined with the
+    device MAC address, then hash the encrypted bytes.
+    """
+    encrypted = rc4(challenge, derive_key(CHALLENGE_KEY, mac))
+    return hashlib.sha1(encrypted).hexdigest()

tinkly/client.py

@@ -0,0 +1,399 @@
+"""Small HTTP client for Twinkly devices."""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+from dataclasses import dataclass, field
+from http import client
+
+from .authentication import make_challenge_response
+from .errors import AuthenticationError, ProtocolError, UnsupportedEndpointError
+
+AUTH_HEADER = 'X-Auth-Token'
+TWINKLY_API_PREFIX = '/xled/v1'
+
+
+def getter(path: str, authenticated: bool = True) -> property:
+    """Create a read-only endpoint property returning a fresh TwinklyResponse.
+
+    Args:
+        path: Endpoint relative to the device's `/xled/v1/` API prefix.
+        authenticated: Obtain a token if needed and include it in each request.
+
+    Reading the property performs an HTTP GET every time; results are not cached.
+    Request errors propagate to the caller.
+    """
+
+    def read(self: TwinklyClient) -> TwinklyResponse:
+        """Fetch the endpoint using this property's authentication setting."""
+        return self.get(path, authenticated=authenticated)
+
+    return property(read)
+
+
+def setter(path: str) -> property:
+    """Create a readable, writable authenticated endpoint property.
+
+    Reads perform HTTP GET and return a fresh TwinklyResponse. Assignments
+    accept a `dict[str, object]` JSON body and perform HTTP POST to the same
+    path, relative to `/xled/v1/`. Assignment discards the response; use
+    TwinklyClient.post when its result is needed. Request errors propagate.
+    """
+
+    def write(self: TwinklyClient, body: dict[str, object]) -> None:
+        """POST the assigned JSON body and discard the response."""
+        self.post(path, body)
+
+    return getter(path).setter(write)
+
+
+@dataclass(frozen=True)
+class TwinklyResponse:
+    """Successful HTTP response and its decoded JSON object."""
+
+    http_status: int
+    """HTTP status code returned by the device."""
+    data: dict[str, object]
+    """Decoded JSON body, including any device application status code."""
+
+
+@dataclass(frozen=True)
+class AuthToken:
+    """Authentication token, verification response, and optional expiry time."""
+
+    value: str = field(repr=False)
+    """Base64 token used in HTTP headers and decoded for realtime UDP packets."""
+    challenge_response: str = field(repr=False)
+    """Challenge response returned by login and sent back during verification."""
+    expires_at: float | None
+    """Expiry as Unix time in seconds, or None if the device supplied no expiry."""
+
+    @property
+    def expired(self) -> bool:
+        """Whether the known expiry time has passed; False if no expiry is known."""
+        return self.expires_at is not None and self.expires_at <= time.time()
+
+
+@dataclass
+class TwinklyClient:
+    """Synchronous HTTP client for a single Twinkly device.
+
+    Endpoint properties return TwinklyResponse records on every read. Writable
+    properties POST assigned JSON dictionaries. Authentication is automatic
+    for protected endpoints. Each request opens and closes an HTTP connection;
+    retries, realtime frame pacing, and reconnection belong to the caller.
+    Serialize all use of a client; instances are not thread-safe.
+    """
+
+    host: str
+    """Device hostname or IPv4 address; HTTP requests use port 80."""
+    mac: str | None = None
+    """Optional MAC address used to check the login challenge response."""
+    timeout: float = 5.0
+    """HTTP connection and socket operation timeout in seconds."""
+    token: AuthToken | None = field(default=None, init=False)
+    """Current authentication token, obtained automatically when needed."""
+
+    # Getters
+    current_movie = getter('led/movies/current')
+    """Read the device's current movie selection."""
+    current_music_driver_set = getter('music/drivers/sets/current')
+    """Read the currently selected music driver set."""
+    current_playlist_entry = getter('playlist/current')
+    """Read the current entry in the device playlist."""
+    device_name = getter('device_name')
+    """Read the device's configured name."""
+    effects = getter('led/effects')
+    """Read the effects available on the device."""
+    firmware_version = getter('fw/version', authenticated=False)
+    """Read the firmware version without logging in."""
+    mic_config = getter('mic/config')
+    """Read the device's microphone configuration."""
+    mic_sample = getter('mic/sample')
+    """Read a microphone sample reported by the device."""
+    movie_config = getter('led/movie/config')
+    """Read the device's movie playback configuration."""
+    movies = getter('movies')
+    """Read the device's stored movie listing."""
+    mqtt_config = getter('mqtt/config')
+    """Read the device's MQTT configuration."""
+    music_driver_sets = getter('music/drivers/sets')
+    """Read the available music driver sets."""
+    music_drivers = getter('music/drivers')
+    """Read the music drivers available on the device."""
+    network_scan_results = getter('network/scan_results')
+    """Read Wi-Fi scan results after starting a scan with start_network_scan()."""
+    network_status = getter('network/status')
+    """Read the device's current network status."""
+    playlist = getter('playlist')
+    """Read the device's configured playlist."""
+    status = getter('status', authenticated=False)
+    """Read device status without logging in."""
+    summary = getter('summary')
+    """Read the device summary supplied by the summary endpoint."""
+
+    # Setters
+    brightness = setter('led/out/brightness')
+    """Read or update output brightness using mode, type, and value fields."""
+    current_effect = setter('led/effects/current')
+    """Read the selected effect or select one by assigning an effect_id body."""
+    layout_full = setter('led/layout/full')
+    """Read or upload the full LED layout, including coordinates and source."""
+    led_color = setter('led/color')
+    """Read or update the static LED color using the device's color fields."""
+    led_config = setter('led/config')
+    """Read or update the device's LED string configuration."""
+    led_mode = setter('led/mode')
+    """Read the operating mode or set it by assigning a body with a mode field."""
+    saturation = setter('led/out/saturation')
+    """Read or update output saturation using mode, type, and value fields."""
+    timer = setter('timer')
+    """Read or update the device timer's time_now, time_on, and time_off fields."""
+
+    def authenticate(self) -> AuthToken:
+        """Log in with a random challenge, verify the issued token, and return it.
+
+        Store the token on this client and calculate its expiry when supplied
+        by the device. Cache only a successfully verified, unexpired token.
+        If mac is set, check the returned challenge response before verification.
+        Invalid or non-positive expiry raises AuthenticationError; authentication
+        and request failures propagate without retrying verification.
+        """
+        challenge = os.urandom(32)
+        login = self.post(
+            'login',
+            {'challenge': base64.b64encode(challenge).decode()},
+            authenticated=False,
+        )
+        data = login.data
+        token = _required_str(data, 'authentication_token')
+        challenge_response = _required_str(data, 'challenge-response')
+
+        if self.mac is not None:
+            expected = make_challenge_response(challenge, self.mac)
+            if challenge_response != expected:
+                raise AuthenticationError(
+                    'Device challenge-response did not match the expected value'
+                )
+
+        expires_in = data.get('authentication_token_expires_in')
+        expires_at = None
+        if expires_in is not None:
+            if isinstance(expires_in, bool) or not isinstance(expires_in, int | str):
+                raise AuthenticationError(
+                    'Login response did not contain numeric '
+                    "'authentication_token_expires_in'"
+                )
+            try:
+                seconds = int(expires_in)
+            except ValueError as err:
+                raise AuthenticationError(
+                    "Login response has invalid 'authentication_token_expires_in'"
+                ) from err
+            if seconds <= 0:
+                raise AuthenticationError(
+                    "Login response requires positive 'authentication_token_expires_in'"
+                )
+            expires_at = time.time() + seconds
+
+        candidate = AuthToken(
+            value=token,
+            challenge_response=challenge_response,
+            expires_at=expires_at,
+        )
+        self._request(
+            'POST',
+            'verify',
+            {'challenge_response': challenge_response},
+            None,
+            'application/json',
+            candidate.value,
+        )
+        if candidate.expired:
+            raise AuthenticationError(
+                "Login 'authentication_token_expires_in' elapsed during verification"
+            )
+        self.token = candidate
+        return candidate
+
+    def get(self, path: str, authenticated: bool = True) -> TwinklyResponse:
+        """GET an API-relative endpoint, optionally obtaining and sending a token."""
+        return self.request('GET', path, authenticated=authenticated)
+
+    def post(
+        self,
+        path: str,
+        body: dict[str, object],
+        authenticated: bool = True,
+    ) -> TwinklyResponse:
+        """POST a JSON object to an API-relative endpoint and return its response.
+
+        Authentication is enabled by default; login uses authenticated=False.
+        """
+        return self.request('POST', path, body=body, authenticated=authenticated)
+
+    def post_bytes(
+        self,
+        path: str,
+        payload: bytes,
+        content_type: str,
+        authenticated: bool = True,
+    ) -> TwinklyResponse:
+        """POST raw bytes with the supplied Content-Type and return the response.
+
+        The path is relative to `/xled/v1/`. Content-Length is calculated from
+        payload. Authentication is enabled unless explicitly disabled.
+        """
+        return self.request(
+            'POST',
+            path,
+            payload=payload,
+            content_type=content_type,
+            authenticated=authenticated,
+        )
+
+    def delete(self, path: str) -> TwinklyResponse:
+        """DELETE an API-relative endpoint using authentication."""
+        return self.request('DELETE', path)
+
+    def echo(self, body: dict[str, object]) -> TwinklyResponse:
+        """POST a JSON object to the authenticated echo endpoint."""
+        return self.post('echo', body)
+
+    def delete_layout_full(self) -> TwinklyResponse:
+        """Delete the device's full LED layout and return its response."""
+        return self.delete('led/layout/full')
+
+    def start_network_scan(self) -> TwinklyResponse:
+        """Start a Wi-Fi network scan and return the device's acknowledgement.
+
+        Read network_scan_results separately once the scan has completed.
+        This method does not wait or poll for completion.
+        """
+        return self.get('network/scan')
+
+    def set_realtime_mode(self) -> TwinklyResponse:
+        """Switch to realtime LED mode before sending UDP frames."""
+        return self.post('led/mode', {'mode': 'rt'})
+
+    def set_off_mode(self) -> TwinklyResponse:
+        """Switch to off mode to turn off the device's LEDs."""
+        return self.post('led/mode', {'mode': 'off'})
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, object] | None = None,
+        payload: bytes | None = None,
+        content_type: str = 'application/json',
+        authenticated: bool = True,
+    ) -> TwinklyResponse:
+        """Send one HTTP request and validate the JSON object response.
+
+        Args:
+            method: HTTP method such as GET, POST, or DELETE.
+            path: Endpoint relative to `/xled/v1/`, without a leading slash.
+            body: Optional JSON object; cannot be combined with payload.
+            payload: Optional raw request bytes.
+            content_type: Content-Type header; defaults to application/json.
+            authenticated: Obtain a token if needed and send X-Auth-Token.
+
+        Returns:
+            HTTP status and decoded JSON data. An empty response body is
+            treated as an empty JSON object.
+
+        Raises:
+            ValueError: Both body and payload were supplied.
+            AuthenticationError: Authentication fails or HTTP 401 is returned.
+                HTTP 401 also clears the stored token.
+            UnsupportedEndpointError: The device returns HTTP 404.
+            ProtocolError: Sending or reading raises OSError or HTTPException,
+                another HTTP error is returned, the body is not a valid UTF-8
+                JSON object, or a supplied application code is not 1000.
+        """
+        if body is not None and payload is not None:
+            raise ValueError('request cannot use both JSON body and binary payload')
+        token = self._auth_token() if authenticated else None
+        return self._request(method, path, body, payload, content_type, token)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        body: dict[str, object] | None,
+        payload: bytes | None,
+        content_type: str,
+        token: str | None,
+    ) -> TwinklyResponse:
+        """Send and validate a request using an explicit token without renewal."""
+        headers = {'Content-Type': content_type}
+        if token is not None:
+            headers[AUTH_HEADER] = token
+        if body is not None:
+            payload = json.dumps(body).encode()
+        if payload is not None:
+            headers['Content-Length'] = str(len(payload))
+
+        connection = client.HTTPConnection(self.host, 80, timeout=self.timeout)
+        try:
+            connection.request(
+                method,
+                f'{TWINKLY_API_PREFIX}/{path}',
+                body=payload,
+                headers=headers,
+            )
+            response = connection.getresponse()
+            raw = response.read()
+        except (OSError, client.HTTPException) as err:
+            raise ProtocolError(
+                f'HTTP {method} {path!r} failed for Twinkly device at {self.host}'
+            ) from err
+        finally:
+            connection.close()
+
+        if response.status == 401:
+            self.token = None
+            raise AuthenticationError('Device rejected the authentication token')
+        if response.status == 404:
+            text = raw.decode(errors='replace')
+            raise UnsupportedEndpointError(path, text)
+        if response.status < 200 or response.status >= 300:
+            raise ProtocolError(
+                f'HTTP {response.status} for {method} {path!r} from {self.host}'
+            )
+
+        try:
+            data = json.loads(raw.decode() or '{}')
+        except (json.JSONDecodeError, UnicodeDecodeError) as err:
+            raise ProtocolError(
+                f'Device returned invalid JSON for {method} {path!r}'
+            ) from err
+        if not isinstance(data, dict):
+            raise ProtocolError(
+                f'Device returned a non-object JSON response for {method} {path!r}'
+            )
+
+        code = data.get('code')
+        if code is not None and code != 1000:
+            raise ProtocolError(f'Twinkly application failure for {method} {path!r}')
+        return TwinklyResponse(http_status=response.status, data=data)
+
+    def _auth_token(self) -> str:
+        """Return the current token, authenticating if it is missing or expired."""
+        if self.token is None or self.token.expired:
+            self.authenticate()
+        if self.token is None:
+            raise AuthenticationError('Authentication did not produce a token')
+        return self.token.value
+
+
+def _required_str(data: dict[str, object], key: str) -> str:
+    """Read a required login string or raise AuthenticationError."""
+    value = data.get(key)
+    if not isinstance(value, str):
+        raise AuthenticationError(f'Login response did not contain string {key!r}')
+    return value

tinkly/discovery.py

@@ -0,0 +1,89 @@
+"""UDP discovery for Twinkly devices."""
+
+from __future__ import annotations
+
+import ipaddress
+import socket
+import time
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+from .errors import DiscoveryError
+
+DISCOVERY_MESSAGE = b'\x01discover'
+DISCOVERY_PORT = 5555
+DEFAULT_BROADCAST = '255.255.255.255'
+
+
+@dataclass(frozen=True)
+class DiscoveredDevice:
+    """Address and identifier advertised by a Twinkly discovery reply."""
+
+    ip_address: str
+    """Device IPv4 address decoded from the discovery packet."""
+    device_id: str
+    """Device identifier decoded from the NUL-terminated reply text."""
+
+
+def parse_discovery_response(data: bytes) -> DiscoveredDevice:
+    """Decode one discovery reply containing an IPv4 address and device ID.
+
+    Raises:
+        DiscoveryError: The packet is too short, lacks OK status, or lacks its
+            terminating NUL byte.
+        UnicodeDecodeError: The device identifier is not valid UTF-8.
+    """
+    if len(data) < 7:
+        raise DiscoveryError(f'Discovery response is too short: {len(data)} bytes')
+    if data[4:6] != b'OK':
+        raise DiscoveryError(f'Discovery response status is not OK: {data[4:6]!r}')
+    if data[-1:] != b'\x00':
+        raise DiscoveryError('Discovery response is not NUL-terminated')
+
+    ip_address = str(ipaddress.ip_address(data[3::-1]))
+    device_id = data[6:-1].decode()
+    return DiscoveredDevice(ip_address, device_id)
+
+
+def discover(
+    timeout: float = 2.0,
+    grouping: float = 0.1,
+    destination: str = DEFAULT_BROADCAST,
+) -> Iterator[DiscoveredDevice]:
+    """Broadcast a discovery request and yield each responding IPv4 address once.
+
+    Args:
+        timeout: Seconds to wait for the first valid device response.
+        grouping: Seconds to collect further responses after the first valid
+            response. Later replies do not extend this window.
+        destination: IPv4 broadcast address or a specific device address.
+
+    Devices are yielded as replies arrive. Exhausting the iterator waits until
+    its deadline; an empty scan waits for timeout. Socket timeouts and the
+    echoed request are ignored. Other socket errors and malformed reply errors
+    propagate. Duplicate devices are identified by their advertised IP address.
+    Consume promptly, normally with list(discover()), to collect the full scan.
+    Time spent by the consumer between results counts toward the deadline and
+    can leave timely replies unread in the socket when the iterator resumes.
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) as sock:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        sock.bind(('', 0))
+        sock.sendto(DISCOVERY_MESSAGE, (destination, DISCOVERY_PORT))
+
+        deadline = time.monotonic() + timeout
+        seen: set[str] = set()
+        while (remaining := deadline - time.monotonic()) > 0:
+            sock.settimeout(remaining)
+            try:
+                data, _address = sock.recvfrom(256)
+            except TimeoutError:
+                continue
+            if data == DISCOVERY_MESSAGE:
+                continue
+            device = parse_discovery_response(data)
+            if not seen:
+                deadline = time.monotonic() + grouping
+            if device.ip_address not in seen:
+                seen.add(device.ip_address)
+                yield device

tinkly/errors.py

@@ -0,0 +1,27 @@
+"""Exceptions for Twinkly protocol operations."""
+
+
+class TinklyError(Exception):
+    """Base error for Twinkly operations."""
+
+
+class DiscoveryError(TinklyError):
+    """A discovery reply has an invalid packet structure or status."""
+
+
+class ProtocolError(TinklyError):
+    """The device returned a response that does not match the protocol."""
+
+
+class UnsupportedEndpointError(ProtocolError):
+    """The device does not support a Twinkly endpoint."""
+
+    def __init__(self, path: str, text: str) -> None:
+        """Retain endpoint and 404 body; omit the body from the error message."""
+        self.path = path
+        self.text = text
+        super().__init__(f'Twinkly endpoint {path!r} is not supported (HTTP 404)')
+
+
+class AuthenticationError(TinklyError):
+    """The authentication handshake failed."""

tinkly/frame.py

@@ -0,0 +1,100 @@
+"""Generation 2 realtime UDP frame sender using protocol version 3."""
+
+from __future__ import annotations
+
+import base64
+import socket
+from collections.abc import Buffer, Iterable
+
+from .errors import ProtocolError
+
+REALTIME_PORT = 7777
+# Twinkly UDP v3 limits each fragment's pixel payload to 900 bytes, excluding headers.
+# https://xled-docs.readthedocs.io/en/latest/protocol_details.html#version-3
+MAX_FRAGMENT_SIZE = 900
+
+
+def frame_packets(
+    token: str,
+    frame: Buffer,
+) -> Iterable[tuple[bytes, memoryview]]:
+    """Yield protocol v3 headers and pixel payload views for one RGB frame.
+
+    Args:
+        token: Base64 authentication token decoding to exactly eight bytes.
+        frame: Contiguous unsigned bytes containing three bytes per RGB LED.
+
+    Each pair contains a twelve-byte header and up to 900 bytes of pixel data.
+    Payload views share the input buffer, which must remain unchanged during
+    transmission. Fragment numbers start at zero and fit in one byte.
+
+    Validation happens as the iterator is consumed. Invalid tokens or more
+    than 256 fragments raise ProtocolError; invalid RGB buffers raise ValueError.
+    """
+    try:
+        raw_token = base64.b64decode(token, validate=True)
+    except ValueError as err:
+        raise ProtocolError('Twinkly realtime token is not valid base64') from err
+    if len(raw_token) != 8:
+        raise ProtocolError('Twinkly realtime token must decode to 8 bytes')
+    payload = frame_payload(frame)
+    for index, start in enumerate(range(0, len(payload), MAX_FRAGMENT_SIZE)):
+        fragment = payload[start : start + MAX_FRAGMENT_SIZE]
+        if index > 255:
+            raise ProtocolError(
+                'Realtime frame is too large for one-byte fragment numbers'
+            )
+        yield b'\x03' + raw_token + b'\x00\x00' + bytes((index,)), fragment
+
+
+def send_frame(
+    host: str, token: str, frame: Buffer, output: socket.socket | None = None
+) -> int:
+    """Send one RGB frame to UDP port 7777 and return total datagram bytes sent.
+
+    Args:
+        host: Device hostname or IPv4 address.
+        token: Base64 token obtained through authentication.
+        frame: Contiguous unsigned RGB bytes, three per LED.
+        output: Optional caller-owned UDP socket. If omitted, create a socket
+            for this call and close it afterward. A supplied socket stays open.
+
+    Authenticate and switch the device to realtime mode before calling. This
+    function sends the fragments once without pacing, retries, or token renewal.
+    The byte count includes packet headers. Buffer validation, protocol, and
+    socket errors propagate; earlier fragments may already have been sent.
+    Callers must serialize complete frame sends to each controller, even when
+    using separate sockets, so fragments from different frames cannot interleave.
+    """
+    if output is not None:
+        return _send_frame(output, host, token, frame)
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) as sock:
+        return _send_frame(sock, host, token, frame)
+
+
+def _send_frame(output: socket.socket, host: str, token: str, frame: Buffer) -> int:
+    """Send each header and payload as one datagram through an existing socket."""
+    sent = 0
+    address = (host, REALTIME_PORT)
+    for header, payload in frame_packets(token, frame):
+        sent += output.sendto(b''.join((header, payload)), address)
+    return sent
+
+
+def frame_payload(frame: Buffer) -> memoryview:
+    """Expose an RGB buffer as a flat unsigned-byte memoryview without copying.
+
+    Accept buffers with format B and C-contiguous storage, including
+    multidimensional views. The byte count must be divisible by three.
+    Raise ValueError for a different element format, non-contiguous storage,
+    or an incomplete RGB pixel. The returned view shares the input buffer.
+    """
+    view = memoryview(frame)
+    if view.format != 'B':
+        raise ValueError('Realtime frames must contain unsigned bytes')
+    if not view.c_contiguous:
+        raise ValueError('Realtime frames must be C-contiguous')
+    payload = view.cast('B')
+    if len(payload) % 3:
+        raise ValueError('Realtime frames must contain three bytes per LED')
+    return payload

tinkly-0.2.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: tinkly
+Version: 0.2.0
+Summary: Low-level Twinkly discovery, authentication, HTTP, and realtime UDP transport
+Requires-Python: >=3.12

tinkly-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+tinkly/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tinkly/authentication.py,sha256=ixtBSLYUGJaNfdJkyPjgoAFcxrCQ6_MDcX9t038-Kls,2062
+tinkly/client.py,sha256=QCyYfArXU3ECiByJFfsH33DSotvJ0xBhA3CRhUL2qVM,16053
+tinkly/discovery.py,sha256=rh9lXGyvobkmddnhbISuHAWr5uy58PGEhjSunMJ-ALU,3387
+tinkly/errors.py,sha256=e-Zon0wGJwaF0AuRyvzeRkhRDpKTkcbI0BJU41INriA,812
+tinkly/frame.py,sha256=lUito5XfhlmTf8fqhV6ADOrNyFB02J_sZbkRX0xKRhw,4229
+tinkly-0.2.0.dist-info/METADATA,sha256=xgnBEwBBcxAnU10ScuC4XoWUKV0Su0JrKJZIse3k3Kc,161
+tinkly-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+tinkly-0.2.0.dist-info/top_level.txt,sha256=_Xnobvvai0ibsQGv7cGHG_r4hU58HkY6SVYZXEIebfc,7
+tinkly-0.2.0.dist-info/RECORD,,

tinkly-0.2.0.dist-info/WHEEL

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

tinkly-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tinkly