python-aidot-cameras 0.1.0__py3-none-any.whl

aidot/discover.py

@@ -0,0 +1,229 @@
+import re
+import socket
+import json
+import time
+import logging
+import asyncio
+import subprocess
+import sys
+from typing import Any, List, Tuple
+
+from .aes_utils import aes_encrypt, aes_decrypt
+from .const import CONF_ID, CONF_IPADDRESS
+from .exceptions import AidotOSError
+
+_LOGGER = logging.getLogger(__name__)
+_DISCOVER_TIME = 5
+
+
+def _get_broadcast_candidates() -> List[Tuple[str, str]]:
+    """Return (bind_ip, broadcast_ip) pairs for every active IPv4 interface.
+
+    Sends a separate broadcast per interface so cameras are reachable
+    regardless of which interface the OS default route prefers.
+    Falls back to a single ("0.0.0.0", "255.255.255.255") entry if
+    interface enumeration is unavailable.
+    """
+    results: List[Tuple[str, str]] = []
+    try:
+        if sys.platform == "darwin":
+            # macOS ifconfig: "inet 192.168.1.175 netmask 0xffffff00 broadcast 192.168.1.255"
+            out = subprocess.check_output(
+                ["/sbin/ifconfig"], text=True, stderr=subprocess.DEVNULL
+            )
+            for m in re.finditer(
+                r"\binet\s+"
+                r"((?!127\.|169\.254\.)\d+\.\d+\.\d+\.\d+)"
+                r"\s+netmask\s+\S+"
+                r"\s+broadcast\s+"
+                r"(\d+\.\d+\.\d+\.\d+)",
+                out,
+            ):
+                results.append((m.group(1), m.group(2)))
+        else:
+            # Linux: "inet 192.168.1.x/24 brd 192.168.1.255"
+            out = subprocess.check_output(
+                ["ip", "addr", "show"], text=True, stderr=subprocess.DEVNULL
+            )
+            for m in re.finditer(
+                r"\binet\s+"
+                r"((?!127\.|169\.254\.)\d+\.\d+\.\d+\.\d+)/\d+"
+                r"\s+brd\s+"
+                r"(\d+\.\d+\.\d+\.\d+)",
+                out,
+            ):
+                results.append((m.group(1), m.group(2)))
+    except Exception as exc:
+        _LOGGER.debug("_get_broadcast_candidates: interface enumeration failed: %s", exc)
+
+    if not results:
+        # Fallback: let the OS pick the outgoing interface
+        results = [("0.0.0.0", "255.255.255.255")]
+
+    _LOGGER.debug("_get_broadcast_candidates: %s", results)
+    return results
+
+
+class BroadcastProtocol:
+    _is_closed = False
+
+    def __init__(self, callback, user_id, broadcast_addr: str = "255.255.255.255") -> None:
+        self.aes_key = bytearray(32)
+        key_string = "T54uednca587"
+        key_bytes = key_string.encode()
+        self.aes_key[: len(key_bytes)] = key_bytes
+
+        self._discover_cb = callback
+        self.user_id = user_id
+        self._broadcast_addr = broadcast_addr
+
+    def connection_made(self, transport) -> None:
+        self.transport = transport
+        sock = transport.get_extra_info("socket")
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+
+    def send_broadcast(self) -> None:
+        if self._is_closed:
+            _LOGGER.error("%s: connection is closed", self.user_id)
+            return
+        current_timestamp_milliseconds = int(time.time() * 1000)
+        seq = str(current_timestamp_milliseconds + 1)[-9:]
+        message = {
+            "protocolVer": "2.0.0",
+            "service": "device",
+            "method": "devDiscoveryReq",
+            "seq": seq,
+            "srcAddr": f"0.{self.user_id}]",
+            "tst": current_timestamp_milliseconds,
+            "payload": {
+                "extends": {},
+                "localCtrFlag": 1,
+                "timestamp": str(current_timestamp_milliseconds),
+            },
+        }
+        send_data = aes_encrypt(json.dumps(message).encode(), self.aes_key)
+        try:
+            sock = self.transport.get_extra_info("socket")
+            local_addr = sock.getsockname() if sock else ("?", 0)
+            self.transport.sendto(send_data, (self._broadcast_addr, 6666))
+            _LOGGER.info(
+                "discovery broadcast sent: %s:%s → %s:6666",
+                local_addr[0], local_addr[1], self._broadcast_addr,
+            )
+        except Exception as error:
+            _LOGGER.error("%s: send failed: %s", self.user_id, error)
+
+    def datagram_received(self, data, addr) -> None:
+        try:
+            data_str = aes_decrypt(data, self.aes_key)
+            data_json = json.loads(data_str)
+        except Exception as exc:
+            _LOGGER.debug("discovery: ignored undecodable packet from %s: %s", addr, exc)
+            return
+        if "payload" in data_json and "mac" in data_json["payload"]:
+            devId = data_json["payload"]["devId"]
+            if self._discover_cb:
+                self._discover_cb(devId, {CONF_IPADDRESS: addr[0]})
+
+    def error_received(self, exc) -> None:
+        _LOGGER.error("%s: error occurred: %s", self.user_id, exc)
+
+    def close(self) -> None:
+        try:
+            self.transport.close()
+        except Exception as error:
+            _LOGGER.error("close error: %s", error)
+
+    def connection_lost(self, exc) -> None:
+        self._is_closed = True
+        if exc:
+            _LOGGER.error("%s: connection lost: %s", self.user_id, exc)
+        else:
+            _LOGGER.info("%s: connection closed", self.user_id)
+
+
+class Discover:
+    _login_info: dict[str, Any] = None
+    discovered_device: dict[str, str]
+    _is_close: bool = False
+
+    def __init__(self, login_info, callback):
+        self.discovered_device = {}
+        self._login_info = login_info
+        self._callback = callback
+        self._protocols: List[BroadcastProtocol] = []
+
+    async def _ensure_sockets(self) -> None:
+        """Create one datagram endpoint per active interface (idempotent)."""
+        if self._protocols:
+            return
+
+        candidates = _get_broadcast_candidates()
+        user_id = self._login_info[CONF_ID]
+
+        for bind_ip, broadcast_ip in candidates:
+            protocol = BroadcastProtocol(
+                self._discover_callback, user_id, broadcast_addr=broadcast_ip
+            )
+            try:
+                await asyncio.get_event_loop().create_datagram_endpoint(
+                    lambda p=protocol: p,
+                    local_addr=(bind_ip, 0),
+                )
+                self._protocols.append(protocol)
+                _LOGGER.debug(
+                    "discovery socket: bind=%s  broadcast=%s", bind_ip, broadcast_ip
+                )
+            except OSError as exc:
+                _LOGGER.debug(
+                    "discovery socket bind %s failed: %s", bind_ip, exc
+                )
+
+        if not self._protocols:
+            # Last-resort fallback
+            protocol = BroadcastProtocol(self._discover_callback, user_id)
+            try:
+                await asyncio.get_event_loop().create_datagram_endpoint(
+                    lambda: protocol,
+                    local_addr=("0.0.0.0", 0),
+                )
+                self._protocols.append(protocol)
+            except OSError:
+                raise AidotOSError
+
+    # ---------------------------------------------------------------------- #
+    # Public API (kept compatible with existing callers)
+    # ---------------------------------------------------------------------- #
+
+    async def try_create_broadcast(self) -> None:
+        await self._ensure_sockets()
+
+    async def send_broadcast(self) -> None:
+        await self._ensure_sockets()
+        for proto in self._protocols:
+            proto.send_broadcast()
+
+    async def repeat_broadcast(self) -> None:
+        self._is_close = False
+        while True:
+            await self.send_broadcast()
+            for _ in range(_DISCOVER_TIME):
+                await asyncio.sleep(1)
+                if self._is_close:
+                    return
+
+    async def fetch_devices_info(self) -> dict[str, str]:
+        await self.send_broadcast()
+        await asyncio.sleep(2)
+        return self.discovered_device
+
+    def _discover_callback(self, dev_id, event: dict[str, str]) -> None:
+        self.discovered_device[dev_id] = event[CONF_IPADDRESS]
+        if self._callback:
+            self._callback(dev_id, event)
+
+    def close(self) -> None:
+        self._is_close = True
+        for proto in self._protocols:
+            proto.close()
+        self._protocols.clear()

aidot/exceptions.py

@@ -0,0 +1,58 @@
+"""AiDot exception hierarchy."""
+
+
+class AidotError(Exception):
+    """Base exception for all AiDot errors."""
+
+
+class InvalidURL(AidotError):
+    """Invalid URL."""
+
+
+class HTTPError(AidotError):
+    """HTTP request failed."""
+
+
+class InvalidHost(AidotError):
+    """Invalid host."""
+
+
+class AidotAuthTokenExpired(AidotError):
+    """Auth token is invalid or expired."""
+
+
+class AidotAuthFailed(AidotError):
+    """Authentication failed."""
+
+
+class AidotNotLogin(AidotError):
+    """Client is not logged in."""
+
+
+class AidotUserOrPassIncorrect(AidotError):
+    """Username or password is incorrect."""
+
+
+class AidotOSError(AidotError):
+    """OS-level error from the AiDot library."""
+
+
+class AidotCameraBusy(AidotError):
+    """Camera refused the live stream with a TERMINAL ack code - retrying is futile.
+
+    Raised when a ``webrtcResp`` carries ``ack.code`` in the terminal set:
+      -50002  WEBRTC_ERROR_EN_RTC_ERR_CODE_SESSION_EXCEED (max concurrent streams)
+      -50015  LIVE_SD_MAX_CONNECT_ERROR (SD-card / connection cap)
+
+    The official app treats both as terminal (shows an error, does NOT retry -
+    decompiled LiveCameraView.java:765). Callers should surface the error rather
+    than burning their retry budget hammering a camera that already said no.
+    """
+
+    def __init__(self, code: int, desc: str = "") -> None:
+        self.code = code
+        self.desc = desc
+        msg = f"camera refused stream: ack code {code}"
+        if desc:
+            msg += f" ({desc})"
+        super().__init__(msg)

aidot/g711.py

@@ -0,0 +1,54 @@
+"""Pure-Python G.711 A-law encoder for two-way-audio (talk).
+
+No stdlib ``audioop`` dependency - that module was removed in Python 3.13 and
+Home Assistant runs on 3.12/3.13.  A-law encode follows the ITU-T G.711
+reference (Sun ``g711.c`` ``linear2alaw``); verified byte-identical to
+``audioop.lin2alaw`` over all 65536 samples on Python <=3.12.
+
+The SDES talk pump (device_client) feeds 20 ms (320-byte) frames of s16le PCM
+@ 8 kHz mono through :func:`pcm_to_alaw` to produce 160-byte PCMA (PT=8) RTP
+payloads.
+"""
+
+from __future__ import annotations
+
+import struct
+
+_SEG_AEND = (0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF)
+
+
+def _search(value: int) -> int:
+    for i, bound in enumerate(_SEG_AEND):
+        if value <= bound:
+            return i
+    return 8
+
+
+def linear2alaw(pcm_val: int) -> int:
+    """Encode one signed 16-bit PCM sample to an 8-bit A-law byte."""
+    pcm_val = pcm_val >> 3  # 16-bit -> 13-bit
+    if pcm_val >= 0:
+        mask = 0xD5
+    else:
+        mask = 0x55
+        pcm_val = -pcm_val - 1
+        if pcm_val < 0:
+            pcm_val = 0
+    seg = _search(pcm_val)
+    if seg >= 8:
+        return 0x7F ^ mask
+    aval = seg << 4
+    if seg < 2:
+        aval |= (pcm_val >> 1) & 0x0F
+    else:
+        aval |= (pcm_val >> seg) & 0x0F
+    return aval ^ mask
+
+
+def pcm_to_alaw(pcm: bytes) -> bytes:
+    """Encode little-endian signed 16-bit PCM bytes to A-law bytes."""
+    n = len(pcm) // 2
+    if n == 0:
+        return b""
+    samples = struct.unpack(f"<{n}h", pcm[: n * 2])
+    return bytes(linear2alaw(s) for s in samples)

aidot/login_const.py

@@ -0,0 +1,13 @@
+"""Constants for the aidot integration."""
+
+APP_ID = "1383974540041977857"
+BASE_URL = "https://prod-us-api.arnoo.com/v17"
+
+PUBLIC_KEY_PEM = b"""
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCtQAnPCi8ksPnS1Du6z96PsKfN
+p2Gp/f/bHwlrAdplbX3p7/TnGpnbJGkLq8uRxf6cw+vOthTsZjkPCF7CatRvRnTj
+c9fcy7yE0oXa5TloYyXD6GkxgftBbN/movkJJGQCc7gFavuYoAdTRBOyQoXBtm0m
+kXMSjXOldI/290b9BQIDAQAB
+-----END PUBLIC KEY-----
+"""

python_aidot_cameras-0.1.0.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: python-aidot-cameras
+Version: 0.1.0
+Summary: Adds camera support to AiDot-Development-Team's  python-AiDot library
+Home-page: https://github.com/cbrightly/python-AiDot
+Author: aidotdev2024
+Author-email: Chris Brightly <chris.brightly@gmail.com>
+Project-URL: Homepage, https://github.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+
+# python-aidot
+
+Control AIDOT WiFi lights **and cameras** from Python and Home Assistant.
+
+This is a camera-capable fork of the upstream lights-only
+[`python-aidot`](https://github.com/Aidot-Development-Team/python-aidot). It adds
+live WebRTC video streaming (DTLS and SDES-SRTP paths), snapshots, PTZ, camera
+controls, cloud recordings/thumbnails, and two-way (push-to-talk) audio, plus a
+Home Assistant custom component that exposes all of it.
+
+## Library install
+
+The camera support is **not published to PyPI** (PyPI only has the upstream
+lights-only releases). Install this fork's library directly from the repo:
+
+```bash
+# lights + camera cloud/control only:
+pip install "git+https://github.com/cbrightly/python-AiDot"
+# add live WebRTC streaming, snapshots, and two-way audio:
+pip install "python-aidot[webrtc] @ git+https://github.com/cbrightly/python-AiDot"
+```
+
+## Home Assistant component
+
+The custom component lives in `custom_components/aidot/`. Its `manifest.json`
+lists the third-party Python dependencies (aiortc, av, paho-mqtt, …) so Home
+Assistant installs those automatically, **but the `aidot` library itself is not
+on PyPI** - install it into Home Assistant's Python environment first:
+
+```bash
+# inside the HA venv / container
+pip install "python-aidot[webrtc] @ git+https://github.com/cbrightly/python-AiDot"
+```
+
+Then copy `custom_components/aidot/` into your HA `config/custom_components/`
+folder (or add this repo to HACS as a custom repository) and restart Home
+Assistant.
+
+## CLI
+
+`test_camera.py` exercises the camera features directly - discovery, LAN probe,
+WebRTC streaming, snapshots, recordings, attribute get/set, and two-way audio
+(`--talk`). Run `python test_camera.py --help` for the full list.

python_aidot_cameras-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+aidot/__init__.py,sha256=tIiGDn9iiYOeFRXbUkZdcCtc6-DvC9J1_sQZjPfPE4I,617
+aidot/aes_utils.py,sha256=luqUzsTTJzZs2O861jGlAJLFZtH_6UBha4H-rvEXGtM,2175
+aidot/client.py,sha256=MUKrq6U-bR9ZwJ1k_MHFJrQNixTeZDrGTyogfhpBE6Y,16967
+aidot/const.py,sha256=ZL4E5jygope729oNt0ddEpaMNmPgrINHjf966gh6hzE,12811
+aidot/credentials.py,sha256=OrusdjH_29Wi6Yq4IeMM1uA9swtf7EwX0-eIUBIUTl0,5784
+aidot/device_client.py,sha256=zeuO1opwcw3ZyCtX1A18RVb3SA1LqWBh0HoAY-z8Oho,598731
+aidot/discover.py,sha256=FBm8L18HS06VXMCtXB0OqxKN-PCEHpISIEeqWpELE0s,8165
+aidot/exceptions.py,sha256=3XmliOOGVtTj96fdv87PkXqMgr7F8-e3tdPIWx1aFuU,1525
+aidot/g711.py,sha256=Ls5BzApKzV0bOKrWiAw8iLqeHx4uUIoo3RJfxYMyPuA,1563
+aidot/login_const.py,sha256=1Gg-hGav5AQ_DPJPIi21clXlx76EwFvhWrg1OQLdbY4,434
+python_aidot_cameras-0.1.0.dist-info/licenses/LICENSE,sha256=5k6Ccd7T5u39Y8730J0qr1ahoaEkd1cahwEccuUZ2Dc,1079
+python_aidot_cameras-0.1.0.dist-info/METADATA,sha256=_MNnaC8r2WOpHsq3wjSabi3xVF0HUM1p_2G9El7PG-M,2339
+python_aidot_cameras-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_aidot_cameras-0.1.0.dist-info/top_level.txt,sha256=_doNL2OOnXeinm1X72eH2wz26wAkZwbM47KhNB6_QzI,6
+python_aidot_cameras-0.1.0.dist-info/RECORD,,

python_aidot_cameras-0.1.0.dist-info/WHEEL

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

python_aidot_cameras-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aidot Development Team
+
+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.

python_aidot_cameras-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aidot