pytydom 0.1.0__tar.gz

pytydom-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Repository Maintainer Council
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytydom-0.1.0/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: pytydom
+Version: 0.1.0
+Summary: Home-Assistant-independent client for Delta Dore Tydom gateways
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9
+Dynamic: license-file
+
+# pytydom
+
+A Home-Assistant-independent Python client for **Delta Dore Tydom**
+gateways. It provides:
+
+- the wire **protocol** — HTTP-over-websocket framing and payload parsing;
+- the authenticated **gateway** session handshake (HTTP Digest → websocket);
+- the **cloud** credential lookup that retrieves a gateway's password from
+  a Delta Dore account.
+
+It raises its own exception hierarchy (`TydomError` and subclasses) and
+takes all endpoints and timeouts as parameters, so it carries no
+dependency on Home Assistant.
+
+This package is developed alongside the `deltadore` Home Assistant
+integration and is intended to be published to PyPI as the integration's
+transport dependency (quality-scale `dependency-transparency`).

pytydom-0.1.0/README.md

@@ -0,0 +1,17 @@
+# pytydom
+
+A Home-Assistant-independent Python client for **Delta Dore Tydom**
+gateways. It provides:
+
+- the wire **protocol** — HTTP-over-websocket framing and payload parsing;
+- the authenticated **gateway** session handshake (HTTP Digest → websocket);
+- the **cloud** credential lookup that retrieves a gateway's password from
+  a Delta Dore account.
+
+It raises its own exception hierarchy (`TydomError` and subclasses) and
+takes all endpoints and timeouts as parameters, so it carries no
+dependency on Home Assistant.
+
+This package is developed alongside the `deltadore` Home Assistant
+integration and is intended to be published to PyPI as the integration's
+transport dependency (quality-scale `dependency-transparency`).

pytydom-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pytydom"
+version = "0.1.0"
+description = "Home-Assistant-independent client for Delta Dore Tydom gateways"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+dependencies = ["aiohttp>=3.9"]
+
+[tool.setuptools.packages.find]
+include = ["pytydom*"]

pytydom-0.1.0/pytydom/__init__.py

@@ -0,0 +1,61 @@
+"""pytydom — a Home-Assistant-independent client for Delta Dore Tydom gateways.
+
+Groups the wire protocol (HTTP-over-websocket framing and payload parsing),
+the authenticated gateway session handshake, and the cloud credential
+lookup used to retrieve a gateway's password from a Delta Dore account.
+"""
+
+from . import cloud, gateway, protocol
+from .cloud import async_get_gateway_password
+from .exceptions import (
+    TydomAuthenticationError,
+    TydomCommunicationError,
+    TydomConnectionError,
+    TydomError,
+)
+from .gateway import async_open_session, async_validate_connection
+from .protocol import (
+    Frame,
+    TydomDevice,
+    build_request,
+    has_pod_position,
+    next_frame,
+    parse_area_links,
+    parse_area_names,
+    parse_areas_data,
+    parse_areas_meta,
+    parse_cmeta,
+    parse_configs,
+    parse_devices_data,
+    parse_energy_cdata,
+    parse_meta,
+    parse_scenarios,
+)
+
+__all__ = [
+    "Frame",
+    "TydomAuthenticationError",
+    "TydomCommunicationError",
+    "TydomConnectionError",
+    "TydomDevice",
+    "TydomError",
+    "async_get_gateway_password",
+    "async_open_session",
+    "async_validate_connection",
+    "build_request",
+    "cloud",
+    "gateway",
+    "has_pod_position",
+    "next_frame",
+    "parse_area_links",
+    "parse_area_names",
+    "parse_areas_data",
+    "parse_areas_meta",
+    "parse_cmeta",
+    "parse_configs",
+    "parse_devices_data",
+    "parse_energy_cdata",
+    "parse_meta",
+    "parse_scenarios",
+    "protocol",
+]

pytydom-0.1.0/pytydom/cloud.py

@@ -0,0 +1,79 @@
+"""Delta Dore cloud client — gateway credential retrieval.
+
+OpenID discovery, ROPC token grant, then
+sites lookup to obtain the Tydom Gateway password for a MAC address.
+"""
+
+import asyncio
+import logging
+
+import aiohttp
+
+from .exceptions import TydomAuthenticationError, TydomCommunicationError
+
+_LOGGER = logging.getLogger(__name__)
+
+DEFAULT_TIMEOUT = 60
+
+
+async def async_get_gateway_password(
+    session: aiohttp.ClientSession,
+    email: str,
+    password: str,
+    mac: str,
+    *,
+    discovery_url: str,
+    sites_url: str,
+    client_id: str,
+    scope: str,
+    timeout: float = DEFAULT_TIMEOUT,
+) -> str:
+    """Return the gateway password registered for `mac` on the account.
+
+    The OpenID discovery URL, sites URL, client id and scope are passed in
+    by the caller (the integration holds Delta Dore's endpoints), so the
+    library embeds no vendor configuration.
+    """
+    try:
+        async with asyncio.timeout(timeout):
+            async with session.get(discovery_url) as resp:
+                token_endpoint = (await resp.json())["token_endpoint"]
+
+            form = aiohttp.FormData()
+            for name, value in (
+                ("username", email),
+                ("password", password),
+                ("grant_type", "password"),
+                ("client_id", client_id),
+                ("scope", scope),
+            ):
+                # content_type forces multipart/form-data, as the endpoint expects
+                form.add_field(name, value, content_type="text/plain")
+            async with session.post(token_endpoint, data=form) as resp:
+                if resp.status != 200:
+                    _LOGGER.debug("Account token rejected: HTTP %s", resp.status)
+                    raise TydomAuthenticationError("Account credentials rejected")
+                access_token = (await resp.json())["access_token"]
+
+            async with session.get(
+                sites_url,
+                params={"gateway_mac": mac},
+                headers={"Authorization": f"Bearer {access_token}"},
+            ) as resp:
+                if resp.status != 200:
+                    _LOGGER.debug("Sites lookup rejected: HTTP %s", resp.status)
+                    raise TydomAuthenticationError("Sites lookup rejected")
+                sites = (await resp.json()).get("sites", [])
+    except (TimeoutError, aiohttp.ClientError, OSError) as err:
+        _LOGGER.debug(
+            "Cloud credential retrieval failed (%s): %s", type(err).__name__, err
+        )
+        raise TydomCommunicationError("Delta Dore cloud unreachable") from err
+
+    for site in sites:
+        gateway = site.get("gateway", {})
+        if gateway.get("mac", "").upper() == mac.upper() and gateway.get("password"):
+            _LOGGER.debug("Gateway password retrieved from the cloud for %s", mac)
+            return gateway["password"]
+    _LOGGER.debug("No gateway %s among the %d account site(s)", mac, len(sites))
+    raise TydomAuthenticationError("No matching gateway on this account")

pytydom-0.1.0/pytydom/exceptions.py

@@ -0,0 +1,21 @@
+"""Exception hierarchy for the Tydom gateway client.
+
+Home-Assistant-independent on purpose: the integration maps these to its
+own Home Assistant errors at the boundary.
+"""
+
+
+class TydomError(Exception):
+    """Base class for every error raised by this library."""
+
+
+class TydomAuthenticationError(TydomError):
+    """Credentials were rejected (gateway digest or cloud account)."""
+
+
+class TydomConnectionError(TydomError):
+    """The gateway could not be reached."""
+
+
+class TydomCommunicationError(TydomError):
+    """The Delta Dore cloud could not be reached."""

pytydom-0.1.0/pytydom/gateway.py

@@ -0,0 +1,236 @@
+"""Tydom Gateway session client — websocket handshake.
+
+HTTP Digest challenge, authenticated
+websocket upgrade, then one HTTP-framed ping to validate the session.
+"""
+
+import asyncio
+import base64
+import hashlib
+import logging
+import re
+import secrets
+import ssl
+import time
+
+import aiohttp
+
+from . import protocol
+from .exceptions import TydomAuthenticationError, TydomConnectionError
+
+_LOGGER = logging.getLogger(__name__)
+
+# Transport defaults; the integration overrides these from its own config.
+DEFAULT_PORT = 443
+DEFAULT_TIMEOUT = 60
+DEFAULT_HEARTBEAT = 20
+
+
+def _build_ssl_context(verify: bool) -> ssl.SSLContext:
+    """Gateway TLS stacks are old: OpenSSL 3 refuses their legacy
+    renegotiation by default, so OP_LEGACY_SERVER_CONNECT is required."""
+    context = ssl.create_default_context()
+    if not verify:
+        context.check_hostname = False
+        context.verify_mode = ssl.CERT_NONE
+    context.options |= getattr(ssl, "OP_LEGACY_SERVER_CONNECT", 0x4)
+    return context
+
+
+# Built at import time: Home Assistant imports integrations off the loop.
+_SSL_CONTEXT_VERIFY = _build_ssl_context(verify=True)
+_SSL_CONTEXT_NO_VERIFY = _build_ssl_context(verify=False)
+
+
+def _md5(value: str) -> str:
+    return hashlib.md5(value.encode()).hexdigest()
+
+
+def _digest_header(
+    mac: str,
+    password: str,
+    realm: str,
+    nonce: str,
+    uri: str,
+    algorithm: str | None,
+    opaque: str | None,
+) -> str:
+    cnonce = secrets.token_hex(8)
+    nc = "00000001"
+    ha1 = _md5(f"{mac}:{realm}:{password}")
+    ha2 = _md5(f"GET:{uri}")
+    response = _md5(f"{ha1}:{nonce}:{nc}:{cnonce}:auth:{ha2}")
+    header = (
+        f'Digest username="{mac}", realm="{realm}", nonce="{nonce}", '
+        f'uri="{uri}", response="{response}", qop=auth, nc={nc}, '
+        f'cnonce="{cnonce}"'
+    )
+    # Challenge directives must be echoed when the gateway sends them.
+    if algorithm:
+        header += f", algorithm={algorithm}"
+    if opaque:
+        header += f', opaque="{opaque}"'
+    return header
+
+
+def _probe_headers() -> dict[str, str]:
+    """Real gateways answer the digest challenge only to upgrade-style
+    requests."""
+    return {
+        "Connection": "Upgrade",
+        "Upgrade": "websocket",
+        "Sec-WebSocket-Key": base64.b64encode(secrets.token_bytes(16)).decode(),
+        "Sec-WebSocket-Version": "13",
+    }
+
+
+async def async_open_session(
+    session: aiohttp.ClientSession,
+    host: str,
+    mac: str,
+    gateway_password: str,
+    verify_tls: bool,
+    *,
+    port: int = DEFAULT_PORT,
+    timeout: float = DEFAULT_TIMEOUT,
+    heartbeat: float = DEFAULT_HEARTBEAT,
+) -> aiohttp.ClientWebSocketResponse:
+    """Perform the digest handshake and return an open websocket."""
+    uri = f"/mediation/client?mac={mac}&appli=1"
+    endpoint = f"{host}:{port}{uri}"
+    ssl_ctx = _SSL_CONTEXT_VERIFY if verify_tls else _SSL_CONTEXT_NO_VERIFY
+    try:
+        async with asyncio.timeout(timeout):
+            async with session.get(
+                f"https://{endpoint}", headers=_probe_headers(), ssl=ssl_ctx
+            ) as resp:
+                challenge = resp.headers.get("WWW-Authenticate", "")
+                _LOGGER.debug(
+                    "Challenge probe to %s: HTTP %s, digest challenge %s",
+                    host,
+                    resp.status,
+                    "present" if challenge else "absent",
+                )
+            realm = re.search(r'realm="([^"]*)"', challenge)
+            nonce = re.search(r'nonce="([^"]*)"', challenge)
+            if not realm or not nonce:
+                # Booting gateways expose HTTPS before their authentication
+                # service: not ready is NOT an authentication failure
+                # (reauth requires an explicit digest rejection).
+                _LOGGER.debug(
+                    "No usable digest challenge from %s: %r", host, challenge[:120]
+                )
+                raise TydomConnectionError(
+                    "Gateway offered no digest challenge (still booting?)"
+                )
+
+            algorithm = re.search(r"algorithm=\"?([A-Za-z0-9\-]+)\"?", challenge)
+            opaque = re.search(r'opaque="([^"]*)"', challenge)
+            auth = _digest_header(
+                mac,
+                gateway_password,
+                realm.group(1),
+                nonce.group(1),
+                uri,
+                algorithm.group(1) if algorithm else None,
+                opaque.group(1) if opaque else None,
+            )
+            websocket = await session.ws_connect(
+                f"wss://{endpoint}",
+                headers={"Authorization": auth},
+                ssl=ssl_ctx,
+                # Second keep-alive level: protocol PINGs (the gateway
+                # drops silent sessions).
+                autoping=True,
+                heartbeat=heartbeat,
+            )
+            _LOGGER.debug("Websocket session established with %s", host)
+            return websocket
+    except aiohttp.WSServerHandshakeError as err:
+        _LOGGER.debug("Websocket upgrade to %s refused: HTTP %s", host, err.status)
+        if err.status == 401:
+            raise TydomAuthenticationError(
+                "Gateway rejected the digest credentials"
+            ) from err
+        raise TydomConnectionError("Websocket upgrade failed") from err
+    except (TimeoutError, aiohttp.ClientError, OSError) as err:
+        _LOGGER.debug(
+            "Gateway connection to %s failed (%s): %s", host, type(err).__name__, err
+        )
+        raise TydomConnectionError("Gateway unreachable") from err
+
+
+def _scan_for_response(buffer: bytes, transac_id: str):
+    """Find our correlated response in the stream, skipping other messages.
+
+    Returns (frame or None, remaining buffer)."""
+    while buffer:
+        try:
+            frame, remainder = protocol.next_frame(buffer)
+        except ValueError:
+            return None, b""
+        if frame is None:
+            return None, remainder
+        if frame.kind == "response" and frame.transac_id == transac_id:
+            return frame, remainder
+        buffer = remainder
+    return None, b""
+
+
+async def async_validate_connection(
+    session: aiohttp.ClientSession,
+    host: str,
+    mac: str,
+    gateway_password: str,
+    verify_tls: bool,
+    remote: bool = False,
+    *,
+    port: int = DEFAULT_PORT,
+    timeout: float = DEFAULT_TIMEOUT,
+    heartbeat: float = DEFAULT_HEARTBEAT,
+) -> None:
+    """Open an authenticated session, ping the gateway, and close.
+
+    The ping response is correlated by Transac-Id while scanning the
+    stream like the runtime router: it may be preceded by unsolicited
+    messages or split across frames, and cloud mode prefixes outbound
+    frames with 0x02.
+    """
+    ws = await async_open_session(
+        session,
+        host,
+        mac,
+        gateway_password,
+        verify_tls,
+        port=port,
+        timeout=timeout,
+        heartbeat=heartbeat,
+    )
+    prefix = b"\x02" if remote else b""
+    # Epoch milliseconds, like every outbound id.
+    transac_id = str(time.time_ns() // 1_000_000)
+    buffer = b""
+    try:
+        async with asyncio.timeout(timeout):
+            await ws.send_bytes(
+                prefix + protocol.build_request("GET", "/ping", transac_id)
+            )
+            while True:
+                msg = await ws.receive()
+                if msg.type not in (aiohttp.WSMsgType.BINARY, aiohttp.WSMsgType.TEXT):
+                    raise TydomConnectionError("Gateway closed the session")
+                raw = (
+                    bytes(msg.data)
+                    if isinstance(msg.data, (bytes, bytearray))
+                    else str(msg.data).encode()
+                )
+                buffer += raw.lstrip(b"\x02")
+                frame, buffer = _scan_for_response(buffer, transac_id)
+                if frame is not None:
+                    if frame.status is not None and 200 <= frame.status < 300:
+                        return
+                    raise TydomConnectionError("Gateway rejected the ping")
+    except (TimeoutError, aiohttp.ClientError, OSError) as err:
+        raise TydomConnectionError("Gateway unreachable") from err
+    finally:
+        await ws.close()

pytydom-0.1.0/pytydom/protocol.py

@@ -0,0 +1,310 @@
+"""HTTP-over-websocket message catalogue for the Tydom Gateway.
+
+Frame building and parsing, inventory payload parsing, and the
+state-application rules (endpoint error must be 0, data element validity
+must be "upToDate").
+"""
+
+import json
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Frame:
+    """One complete HTTP message extracted from the websocket stream."""
+
+    kind: str  # "request" or "response"
+    path: str
+    transac_id: str | None
+    body: str
+    method: str | None = None
+    status: int | None = None
+
+    @property
+    def json(self):
+        return json.loads(self.body) if self.body.strip() else None
+
+
+def build_request(method: str, path: str, transac_id: str, body: str = "") -> bytes:
+    """Serialize an outbound request frame."""
+    return (
+        f"{method} {path} HTTP/1.1\r\n"
+        f"Content-Length: {len(body.encode())}\r\n"
+        "Content-Type: application/json; charset=UTF-8\r\n"
+        f"Transac-Id: {transac_id}\r\n\r\n{body}"
+    ).encode()
+
+
+def _consume_chunked(payload: bytes) -> tuple[bytes, int] | None:
+    """Extract one chunked body: (body, bytes consumed), or None while
+    incomplete. Raises ValueError on malformed chunk sizes."""
+    out = bytearray()
+    offset = 0
+    while True:
+        line_end = payload.find(b"\r\n", offset)
+        if line_end == -1:
+            return None
+        size = int(payload[offset:line_end].strip(), 16)
+        data_start = line_end + 2
+        if size == 0:
+            if len(payload) < data_start + 2:
+                return None
+            return bytes(out), data_start + 2
+        if len(payload) < data_start + size + 2:
+            return None
+        out += payload[data_start : data_start + size]
+        offset = data_start + size + 2
+
+
+def next_frame(buffer: bytes) -> tuple[Frame | None, bytes]:
+    """Extract the first complete message from the websocket byte stream.
+
+    The stream is continuous HTTP/1.1: one websocket frame may carry
+    several messages and one message may span frames. Returns
+    (frame, remainder); frame is None when nothing was parsed —
+    remainder == b"" means non-HTTP bytes were dropped, an unchanged
+    remainder means the message is still incomplete. Message bodies end
+    at the chunked terminal zero chunk, after Content-Length bytes, or
+    immediately when neither marker is present (headers-only
+    acknowledgements). Raises ValueError on malformed framing.
+    """
+    head, sep, rest = buffer.partition(b"\r\n\r\n")
+    lines = head.decode(errors="ignore").split("\r\n")
+    first = lines[0].split(" ")
+    is_response = first[0].startswith("HTTP/") and len(first) >= 2
+    is_request = len(first) >= 3 and first[2].startswith("HTTP/")
+    if not is_response and not is_request:
+        return None, b""
+    if not sep:
+        return None, buffer
+    headers = {}
+    for line in lines[1:]:
+        name, _, value = line.partition(":")
+        headers[name.strip().lower()] = value.strip()
+
+    if headers.get("transfer-encoding", "").lower().startswith("chunk"):
+        consumed = _consume_chunked(rest)
+        if consumed is None:
+            return None, buffer
+        body_bytes, used = consumed
+        remainder = rest[used:]
+    elif "content-length" in headers:
+        length = int(headers["content-length"])
+        if len(rest) < length:
+            return None, buffer
+        body_bytes, remainder = rest[:length], rest[length:]
+    else:
+        body_bytes, remainder = b"", rest
+
+    frame = Frame(
+        kind="response" if is_response else "request",
+        status=int(first[1]) if is_response else None,
+        method=None if is_response else first[0],
+        path=headers.get("uri-origin", "") if is_response else first[1],
+        transac_id=headers.get("transac-id"),
+        body=body_bytes.decode(errors="ignore"),
+    )
+    return frame, remainder
+
+
+@dataclass
+class TydomDevice:
+    """One gateway endpoint, identified by "{id_endpoint}_{id_device}"."""
+
+    key: str
+    device_id: int
+    endpoint_id: int
+    name: str
+    usage: str
+    data: dict = field(default_factory=dict)
+    metadata: dict = field(default_factory=dict)
+    energy_dests: list = field(default_factory=list)
+    energy_srcs: list = field(default_factory=list)
+    energy_units: list = field(default_factory=list)
+    area_name: str | None = None
+    _listeners: list = field(default_factory=list)
+
+    def add_listener(self, listener):
+        """Register a state-change callback; returns its remover."""
+        self._listeners.append(listener)
+
+        def _remove():
+            self._listeners.remove(listener)
+
+        return _remove
+
+    def apply(self, data: dict) -> None:
+        """Apply confirmed state values and notify listeners."""
+        self.data.update(data)
+        for listener in list(self._listeners):
+            listener()
+
+
+def has_pod_position(device: TydomDevice) -> bool:
+    """Motorized doors carry podPosition; they map to lock, not contact."""
+    return "podPosition" in device.data or "podPosition" in device.metadata
+
+
+def parse_configs(payload) -> dict[str, dict]:
+    """Endpoint directory from /configs/file, keyed by device key."""
+    entries = {}
+    for endpoint in (payload or {}).get("endpoints", []):
+        key = f"{endpoint['id_endpoint']}_{endpoint['id_device']}"
+        entries[key] = {
+            "device_id": endpoint["id_device"],
+            "endpoint_id": endpoint["id_endpoint"],
+            "name": endpoint["name"],
+            "usage": endpoint["last_usage"] or "unknown",
+        }
+    return entries
+
+
+def parse_meta(payload) -> dict[str, dict]:
+    """Attribute metadata from /devices/meta, keyed by device key."""
+    entries = {}
+    for device in payload or []:
+        for endpoint in device.get("endpoints", []):
+            key = f"{endpoint['id']}_{device['id']}"
+            entries[key] = {meta["name"]: meta for meta in endpoint.get("metadata", [])}
+    return entries
+
+
+def parse_scenarios(payload) -> list[dict]:
+    """Scenario definitions from the /configs/file `scenarios` array."""
+    return [
+        {"id": scenario["id"], "name": scenario["name"]}
+        for scenario in (payload or {}).get("scenarios", [])
+    ]
+
+
+def parse_area_names(payload) -> dict[int, str]:
+    """Thermal-zone names from the /configs/file `areas` array."""
+    return {
+        area["id"]: area["name"]
+        for area in (payload or {}).get("areas", [])
+        if "id" in area and "name" in area
+    }
+
+
+def parse_area_links(payload) -> dict[str, int]:
+    """Device-key → area id from the /devices/meta endpoint `link`."""
+    links: dict[str, int] = {}
+    for device in payload or []:
+        for endpoint in device.get("endpoints", []):
+            link = endpoint.get("link") or {}
+            if link.get("type") == "area" and link.get("id") is not None:
+                links[f"{endpoint['id']}_{device['id']}"] = link["id"]
+    return links
+
+
+def parse_areas_meta(payload) -> dict[int, dict]:
+    """Zone attribute metadata from /areas/meta, keyed by area id."""
+    entries: dict[int, dict] = {}
+    for area in payload or []:
+        entries[area["id"]] = {meta["name"]: meta for meta in area.get("metadata", [])}
+    return entries
+
+
+def parse_areas_data(payload) -> dict[int, dict]:
+    """Confirmed zone state from an /areas/data body, keyed by area id.
+
+    Same shape as a flat /devices/data element but the top-level `id`
+    is an area id and there is no `endpoints` key.
+    """
+    entries: dict[int, dict] = {}
+    for area in payload or []:
+        if area.get("error", 0) != 0:
+            continue
+        entries[area["id"]] = {
+            element["name"]: element["value"]
+            for element in area.get("data", [])
+            if element.get("validity") == "upToDate"
+        }
+    return entries
+
+
+def parse_cmeta(payload) -> dict[str, dict]:
+    """Energy capabilities advertised by /devices/cmeta, per key:
+    energyIndex destinations, energyDistrib sources, and energyInstant
+    units."""
+    entries: dict[str, dict] = {}
+    for device in payload or []:
+        for endpoint in device.get("endpoints", []):
+            key = f"{endpoint['id']}_{device['id']}"
+            dests: list = []
+            srcs: list = []
+            units: list = []
+            for cmeta in endpoint.get("cmetadata", []):
+                name = cmeta.get("name")
+                if name == "energyIndex":
+                    for parameter in cmeta.get("parameters", []):
+                        if parameter.get("name") == "dest":
+                            dests.extend(parameter.get("enum_values", []))
+                elif name == "energyDistrib":
+                    for parameter in cmeta.get("parameters", []):
+                        if parameter.get("name") == "src":
+                            srcs.extend(parameter.get("enum_values", []))
+                elif name == "energyInstant":
+                    for parameter in cmeta.get("parameters", []):
+                        if parameter.get("name") == "unit":
+                            units.extend(parameter.get("enum_values", []))
+            if dests or srcs or units:
+                entries[key] = {"dests": dests, "srcs": srcs, "units": units}
+    return entries
+
+
+def parse_energy_cdata(payload) -> dict[str, dict]:
+    """Energy counters from a cdata response, keyed by device key."""
+    entries: dict[str, dict] = {}
+    for device in payload or []:
+        for endpoint in device.get("endpoints", []):
+            if endpoint.get("error", 0) != 0:
+                continue
+            key = f"{endpoint['id']}_{device['id']}"
+            values = {}
+            for element in endpoint.get("cdata", []):
+                name = element.get("name")
+                if name == "energyIndex":
+                    dest = element.get("parameters", {}).get("dest")
+                    counter = element.get("values", {}).get("counter")
+                    if dest is not None and counter is not None:
+                        values[f"energyIndex_{dest}"] = counter
+                elif name == "energyDistrib":
+                    # The distribution echo carries a date plus one
+                    # counter per breakdown slot, keyed by slot name.
+                    for slot, counter in element.get("values", {}).items():
+                        if slot != "date" and isinstance(counter, (int, float)):
+                            values[f"energyIndex_{slot}"] = counter
+                elif name == "energyInstant":
+                    unit = element.get("parameters", {}).get("unit")
+                    measure = element.get("values", {}).get("measure")
+                    if unit is not None and isinstance(measure, (int, float)):
+                        # Hundredths of the physical unit (trace truth).
+                        values[f"energyInstant_{unit}"] = measure / 100
+            if values:
+                entries[key] = values
+    return entries
+
+
+def parse_devices_data(payload) -> dict[str, dict]:
+    """Confirmed state values from a /devices/data body, keyed by device key.
+
+    Application rules: endpoints with a non-zero error are skipped; data
+    elements are kept only when their validity is "upToDate".
+    """
+    if isinstance(payload, dict):
+        payload = [payload]
+    entries: dict[str, dict] = {}
+    for device in payload or []:
+        for endpoint in device.get("endpoints", []):
+            if endpoint.get("error", 0) != 0:
+                continue
+            key = f"{endpoint['id']}_{device['id']}"
+            values = {
+                element["name"]: element["value"]
+                for element in endpoint.get("data", [])
+                if element.get("validity") == "upToDate"
+            }
+            if values:
+                entries[key] = values
+    return entries

pytydom-0.1.0/pytydom.egg-info/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: pytydom
+Version: 0.1.0
+Summary: Home-Assistant-independent client for Delta Dore Tydom gateways
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9
+Dynamic: license-file
+
+# pytydom
+
+A Home-Assistant-independent Python client for **Delta Dore Tydom**
+gateways. It provides:
+
+- the wire **protocol** — HTTP-over-websocket framing and payload parsing;
+- the authenticated **gateway** session handshake (HTTP Digest → websocket);
+- the **cloud** credential lookup that retrieves a gateway's password from
+  a Delta Dore account.
+
+It raises its own exception hierarchy (`TydomError` and subclasses) and
+takes all endpoints and timeouts as parameters, so it carries no
+dependency on Home Assistant.
+
+This package is developed alongside the `deltadore` Home Assistant
+integration and is intended to be published to PyPI as the integration's
+transport dependency (quality-scale `dependency-transparency`).

pytydom-0.1.0/pytydom.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+pytydom/__init__.py
+pytydom/cloud.py
+pytydom/exceptions.py
+pytydom/gateway.py
+pytydom/protocol.py
+pytydom.egg-info/PKG-INFO
+pytydom.egg-info/SOURCES.txt
+pytydom.egg-info/dependency_links.txt
+pytydom.egg-info/requires.txt
+pytydom.egg-info/top_level.txt

pytydom-0.1.0/pytydom.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pytydom-0.1.0/pytydom.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>=3.9

pytydom-0.1.0/pytydom.egg-info/top_level.txt

@@ -0,0 +1 @@
+pytydom

pytydom-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+