pycloudedge 0.1.4.dev3__tar.gz → 0.1.5.dev0__tar.gz

{pycloudedge-0.1.4.dev3 → pycloudedge-0.1.5.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycloudedge
-Version: 0.1.4.dev3
+Version: 0.1.5.dev0
 Summary: Python library for CloudEdge cameras
 Home-page: https://github.com/fradaloisio/pycloudedge
 Author: Francesco D'Aloisio
@@ -29,7 +29,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.25.0
 Requires-Dist: cryptography>=3.4.0
+Requires-Dist: pycryptodome>=3.15.0
 Requires-Dist: python-dotenv>=0.19.0
+Provides-Extra: mqtt
+Requires-Dist: paho-mqtt>=2.0.0; extra == "mqtt"
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.18.0; extra == "dev"

{pycloudedge-0.1.4.dev3 → pycloudedge-0.1.5.dev0}/cloudedge/__init__.py

@@ -15,6 +15,7 @@ from .client import (
     DEVICE_STATUS_DORMANCY,
     DEVICE_STATUS_OFFLINE,
 )
+from .mqtt import CloudEdgeMqttListener, ALARM_TYPE_NAMES, MOTION_ALARM_TYPES
 from .exceptions import (
     CloudEdgeError, AuthenticationError, DeviceNotFoundError, 
     ConfigurationError, NetworkError, ValidationError, RateLimitError
@@ -32,6 +33,9 @@ __all__ = [
     'DEVICE_STATUS_ONLINE',
     'DEVICE_STATUS_DORMANCY',
     'DEVICE_STATUS_OFFLINE',
+    'CloudEdgeMqttListener',
+    'ALARM_TYPE_NAMES',
+    'MOTION_ALARM_TYPES',
     'CloudEdgeError', 
     'AuthenticationError',
     'DeviceNotFoundError',

{pycloudedge-0.1.4.dev3 → pycloudedge-0.1.5.dev0}/cloudedge/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.4.dev3'
-__version_tuple__ = version_tuple = (0, 1, 4, 'dev3')
+__version__ = version = '0.1.5.dev0'
+__version_tuple__ = version_tuple = (0, 1, 5, 'dev0')
 
-__commit_id__ = commit_id = 'gc5b1ac2e4'
+__commit_id__ = commit_id = 'ga05fef1a8'

{pycloudedge-0.1.4.dev3 → pycloudedge-0.1.5.dev0}/cloudedge/client.py

@@ -653,9 +653,15 @@ class CloudEdgeClient:
                     "caKey": ca_key,
                     "loginTime": int(time.time()),
                     "apiServer": self.BASE_URL,
-                    "iotPlatformKeys": iot_platform_keys
+                    "iotPlatformKeys": iot_platform_keys,
                 }
-                
+
+                # Fetch MQTT / IoT platform config (host, port, mqtt signature)
+                try:
+                    self._fetch_iot_config()
+                except Exception as exc:
+                    self._log(f"IoT config fetch failed (non-fatal): {exc}")
+
                 self._save_session_cache(self.session_data)
                 return True
             else:
@@ -671,6 +677,155 @@ class CloudEdgeClient:
         except json.JSONDecodeError:
             raise AuthenticationError("Failed to parse login response")
             
+    @staticmethod
+    def _aes_cbc_decrypt(ciphertext_b64: str, key_str: str) -> str:
+        """AES-CBC decrypt (key == IV, PKCS7 padding).
+
+        Uses PyCryptodome when available (more lenient on padding edge cases
+        found in Meari responses), falls back to ``cryptography``.
+        """
+        key = key_str.encode("utf-8")
+        pad_len = 4 - len(ciphertext_b64) % 4 if len(ciphertext_b64) % 4 else 0
+        ct = base64.b64decode(ciphertext_b64 + "=" * pad_len)
+
+        try:
+            from Crypto.Cipher import AES
+            from Crypto.Util.Padding import unpad
+            cipher = AES.new(key, AES.MODE_CBC, key)
+            return unpad(cipher.decrypt(ct), AES.block_size).decode("utf-8")
+        except ImportError:
+            from cryptography.hazmat.primitives.ciphers import (
+                Cipher, algorithms, modes,
+            )
+            from cryptography.hazmat.primitives import padding
+            cipher = Cipher(algorithms.AES(key), modes.CBC(key))
+            decryptor = cipher.decryptor()
+            padded = decryptor.update(ct) + decryptor.finalize()
+            unpadder = padding.PKCS7(128).unpadder()
+            return (unpadder.update(padded) + unpadder.finalize()).decode("utf-8")
+
+    def _fetch_iot_config(self) -> None:
+        """Fetch MQTT and OpenAPI config from ``/v2/app/config/pf/init``.
+
+        Decrypts the platform signature to obtain the real ``access_id`` and
+        ``access_key`` required by the MQTT broker.  Stores results in
+        ``self.session_data["mqtt"]``.
+
+        Called automatically after a successful :meth:`authenticate`.
+        """
+        if not self.session_data:
+            return
+
+        user_token = self.session_data["userToken"]
+        user_id = self.session_data["userID"]
+        ts = int(time.time() * 1000)
+
+        params = {
+            'appVer': '5.5.1', 'appVerCode': '551', 'lngType': 'en',
+            'phoneType': 'a', 'sdkVer': '1.0.0', 'sourceApp': '8',
+            'countryCode': self.country_code,
+            'phoneCode': self.phone_code,
+            'iotType': '4',
+            'signatureMethod': 'HMAC-SHA1', 'signatureVersion': '1.0',
+            'signatureNonce': str(ts),
+            't': str(ts), 'timestamp': str(ts),
+            'userID': str(user_id),
+        }
+        sorted_keys = sorted(params.keys())
+        content = "&".join(f"{k}={params[k]}" for k in sorted_keys)
+        params['signature'] = base64.b64encode(
+            hmac.new(user_token.encode(), content.encode(), hashlib.sha1).digest()
+        ).decode()
+
+        xca_headers = self._generate_xca_headers(
+            f"api=/ppstrongs/v2/app/config/pf/init"
+            f"|X-Ca-Key={user_token}"
+            f"|X-Ca-Timestamp={str(ts)}"
+            f"|X-Ca-Nonce={str(ts % 100000000)}",
+            user_token,
+        )
+
+        try:
+            resp = self._session.get(
+                f"{self.BASE_URL}/v2/app/config/pf/init",
+                params=params,
+                headers={**DEFAULT_HEADERS, **xca_headers},
+                timeout=DEFAULT_TIMEOUT,
+            )
+            data = resp.json()
+            if data.get("resultCode") != "1001":
+                self._log(f"IoT config response: {data.get('resultCode')}")
+                return
+
+            pf = data.get("result", {}).get("pfApi", {})
+
+            # ── Decrypt platform signature to get real access_id/key ─────
+            #
+            # The MQTT broker authenticates with the *decrypted* access_id
+            # (not the raw "mearicloud" value from the login response).
+            # Key derivation: base64(userID + PARTNER_ID + TTID + expireTime)[:16]
+            PARTNER_ID = "8"
+            TTID = "a"
+
+            access_id = ""
+            access_key = ""
+            platform = pf.get("platform", {})
+            plat_sig = platform.get("signature", "")
+            expire_time = str(platform.get("expireTime", ""))
+
+            if plat_sig and expire_time:
+                try:
+                    key_raw = f"{user_id}{PARTNER_ID}{TTID}{expire_time}"
+                    key16 = base64.b64encode(key_raw.encode()).decode().rstrip("=")[:16]
+                    decrypted = self._aes_cbc_decrypt(plat_sig, key16)
+                    info_b64 = decrypted.split("-")[0]
+                    pad = 4 - len(info_b64) % 4 if len(info_b64) % 4 else 0
+                    info_json = base64.b64decode(info_b64 + "=" * pad).decode()
+                    info = json.loads(info_json)
+                    access_id = info.get("accessid", "")
+                    access_key = info.get("accesskey", "")
+                    self._log(f"Decrypted MQTT access_id: {access_id[:12]}...")
+                except Exception as exc:
+                    self._log(f"Platform signature decryption failed: {exc}")
+
+            mqtt_cfg = pf.get("mqtt", {})
+            self.session_data["mqtt"] = {
+                "mqtt_host": mqtt_cfg.get("host", ""),
+                "mqtt_port": int(mqtt_cfg.get("port", 1883)),
+                "mqtt_signature": pf.get("mqttSignature", ""),
+                "mqtt_access_id": access_id,
+                "mqtt_access_key": access_key,
+            }
+            self._log(
+                f"MQTT config: {self.session_data['mqtt']['mqtt_host']}"
+                f":{self.session_data['mqtt']['mqtt_port']}"
+            )
+        except Exception as exc:
+            self._log(f"Failed to fetch IoT config: {exc}")
+
+    def get_mqtt_config(self) -> Optional[Dict[str, Any]]:
+        """Return MQTT connection parameters, or ``None`` if unavailable.
+
+        The returned dict contains:
+
+        * ``mqtt_host`` (str)
+        * ``mqtt_port`` (int)
+        * ``mqtt_signature`` (str) — password for the MQTT broker
+        * ``mqtt_access_id`` (str) — username for the MQTT broker
+        * ``user_id`` (int | str) — used in the topic path
+
+        Call :meth:`authenticate` first.
+        """
+        if not self.session_data:
+            return None
+        mqtt = self.session_data.get("mqtt")
+        if not mqtt or not mqtt.get("mqtt_host"):
+            return None
+        return {
+            **mqtt,
+            "user_id": self.session_data.get("userID"),
+        }
+
     def _generate_device_body(self, extra_params: Optional[Dict] = None) -> Dict:
         """Generate device body for API requests."""
         if not self.session_data:

pycloudedge-0.1.5.dev0/cloudedge/mqtt.py

@@ -0,0 +1,241 @@
+"""CloudEdge MQTT event listener.
+
+Subscribes to the Meari/CloudEdge MQTT broker and dispatches push events
+(motion detection, camera wake, tamper, etc.) in real-time.
+
+Requires ``paho-mqtt`` (optional dependency)::
+
+    pip install paho-mqtt
+
+Usage::
+
+    from cloudedge import CloudEdgeClient
+    from cloudedge.mqtt import CloudEdgeMqttListener
+
+    client = CloudEdgeClient(...)
+    client.authenticate()
+
+    def on_event(device_id, event_name, event_type, is_motion):
+        print(f"{device_id}: {event_name}  motion={is_motion}")
+
+    listener = CloudEdgeMqttListener(client, on_event=on_event)
+    listener.start()       # non-blocking (background thread)
+    ...
+    listener.stop()
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import ssl
+from typing import Any, Callable, Dict, Optional
+
+_LOGGER = logging.getLogger(__name__)
+
+ALARM_TYPE_NAMES: Dict[int, str] = {
+    1: "PIR",
+    2: "Motion",
+    3: "Visitor",
+    6: "Noise",
+    7: "Baby cry",
+    8: "Face",
+    9: "Call",
+    10: "Tamper",
+    11: "Human body",
+    12: "Face detected",
+    14: "Dog bark",
+    17: "Cat",
+    18: "Pet",
+    19: "Package",
+    20: "Person",
+    21: "SD card removed",
+    39: "Fire",
+    41: "Cat meow",
+}
+
+MOTION_ALARM_TYPES: frozenset[int] = frozenset({1, 2, 11, 20})
+
+OnEventCallback = Callable[[str, str, int, bool], None]
+"""Signature: (device_id, event_name, event_type_int, is_motion) -> None"""
+
+
+class CloudEdgeMqttListener:
+    """Subscribe to the CloudEdge/Meari MQTT broker for push events.
+
+    Args:
+        client: An authenticated :class:`~cloudedge.client.CloudEdgeClient`.
+        on_event: Callback invoked for **every** event.
+        on_motion: Callback invoked only for motion-related events.
+        on_connect: Called when the MQTT connection is established.
+        on_disconnect: Called when the MQTT connection drops.
+    """
+
+    def __init__(
+        self,
+        client: Any,
+        *,
+        on_event: Optional[OnEventCallback] = None,
+        on_motion: Optional[OnEventCallback] = None,
+        on_connect: Optional[Callable[[], None]] = None,
+        on_disconnect: Optional[Callable[[], None]] = None,
+    ) -> None:
+        mqtt_cfg = client.get_mqtt_config()
+        if not mqtt_cfg:
+            raise RuntimeError(
+                "MQTT config not available — call client.authenticate() first"
+            )
+
+        self._host = mqtt_cfg["mqtt_host"]
+        self._port = mqtt_cfg["mqtt_port"]
+        self._username = mqtt_cfg["mqtt_access_id"]
+        self._password = mqtt_cfg["mqtt_signature"]
+        self._user_id = str(mqtt_cfg["user_id"])
+        self._topic = (
+            f"$bsssvr/iot/{self._user_id}/{self._user_id}/event/update/accepted"
+        )
+
+        self.on_event = on_event
+        self.on_motion = on_motion
+        self._on_connect_cb = on_connect
+        self._on_disconnect_cb = on_disconnect
+
+        self._client: Any = None
+        self._connected = False
+
+    @property
+    def connected(self) -> bool:
+        """``True`` if the MQTT connection is active."""
+        return self._connected
+
+    @property
+    def topic(self) -> str:
+        """The MQTT topic being subscribed to."""
+        return self._topic
+
+    def start(self) -> bool:
+        """Start the MQTT background loop (non-blocking).
+
+        Returns ``True`` if the connection was initiated successfully.
+        Raises ``ImportError`` if ``paho-mqtt`` is not installed.
+        """
+        try:
+            import paho.mqtt.client as mqtt
+        except ImportError:
+            raise ImportError(
+                "paho-mqtt is required for MQTT support: pip install paho-mqtt"
+            )
+
+        def _on_connect(client, userdata, flags, rc, *args):
+            # paho-mqtt v2 passes rc as ReasonCode object, not int
+            rc_ok = (rc == 0) if isinstance(rc, int) else rc.is_failure is False
+            if rc_ok:
+                self._connected = True
+                client.subscribe(self._topic, qos=2)
+                _LOGGER.info("MQTT connected — topic: %s", self._topic)
+                if self._on_connect_cb:
+                    self._on_connect_cb()
+            else:
+                _LOGGER.warning("MQTT connect failed: rc=%s", rc)
+
+        def _on_disconnect(client, userdata, *args):
+            self._connected = False
+            _LOGGER.debug("MQTT disconnected")
+            if self._on_disconnect_cb:
+                self._on_disconnect_cb()
+
+        def _on_message(client, userdata, msg):
+            try:
+                self._dispatch(msg.payload)
+            except Exception as exc:
+                _LOGGER.debug("MQTT message parse error: %s", exc)
+
+        try:
+            client = mqtt.Client(
+                callback_api_version=mqtt.CallbackAPIVersion.VERSION2,
+                client_id=self._user_id,
+                clean_session=True,
+                protocol=mqtt.MQTTv311,
+            )
+        except (AttributeError, TypeError):
+            client = mqtt.Client(
+                client_id=self._user_id,
+                clean_session=True,
+                protocol=mqtt.MQTTv311,
+            )
+
+        client.username_pw_set(self._username, self._password)
+
+        ssl_ctx = ssl.create_default_context()
+        ssl_ctx.check_hostname = False
+        ssl_ctx.verify_mode = ssl.CERT_NONE
+        client.tls_set_context(ssl_ctx)
+
+        client.on_connect = _on_connect
+        client.on_disconnect = _on_disconnect
+        client.on_message = _on_message
+        client.reconnect_delay_set(min_delay=3, max_delay=60)
+
+        self._client = client
+
+        try:
+            client.connect_async(self._host, self._port, keepalive=300)
+            client.loop_start()
+            return True
+        except Exception as exc:
+            _LOGGER.error("MQTT connection failed: %s", exc)
+            self._connected = False
+            return False
+
+    def stop(self) -> None:
+        """Stop the MQTT background loop and disconnect."""
+        if self._client:
+            try:
+                self._client.loop_stop()
+                self._client.disconnect()
+            except Exception:
+                pass
+            self._client = None
+            self._connected = False
+
+    def _dispatch(self, payload: bytes) -> None:
+        """Parse an MQTT payload and invoke callbacks."""
+        try:
+            data: dict = json.loads(payload.decode("utf-8"))
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            return
+
+        # Unwrap nested envelope: params → data → msg
+        for key in ("params", "data"):
+            if key in data and isinstance(data[key], dict):
+                data = data[key]
+        if "msg" in data and isinstance(data["msg"], dict):
+            data = data["msg"]
+
+        evt_raw = data.get("evt", data.get("eventType", ""))
+        device_id = str(data.get("deviceID", data.get("deviceId", "")))
+
+        try:
+            evt_int = int(evt_raw)
+        except (ValueError, TypeError):
+            evt_int = -1
+
+        evt_name = ALARM_TYPE_NAMES.get(evt_int, f"type={evt_raw}")
+        is_motion = evt_int in MOTION_ALARM_TYPES
+
+        _LOGGER.info(
+            "MQTT event: %s  device=%s  motion=%s",
+            evt_name, device_id, is_motion,
+        )
+
+        if self.on_event:
+            try:
+                self.on_event(device_id, evt_name, evt_int, is_motion)
+            except Exception as exc:
+                _LOGGER.debug("on_event callback error: %s", exc)
+
+        if is_motion and self.on_motion:
+            try:
+                self.on_motion(device_id, evt_name, evt_int, is_motion)
+            except Exception as exc:
+                _LOGGER.debug("on_motion callback error: %s", exc)

{pycloudedge-0.1.4.dev3 → pycloudedge-0.1.5.dev0}/pycloudedge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycloudedge
-Version: 0.1.4.dev3
+Version: 0.1.5.dev0
 Summary: Python library for CloudEdge cameras
 Home-page: https://github.com/fradaloisio/pycloudedge
 Author: Francesco D'Aloisio
@@ -29,7 +29,10 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests>=2.25.0
 Requires-Dist: cryptography>=3.4.0
+Requires-Dist: pycryptodome>=3.15.0
 Requires-Dist: python-dotenv>=0.19.0
+Provides-Extra: mqtt
+Requires-Dist: paho-mqtt>=2.0.0; extra == "mqtt"
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.18.0; extra == "dev"

{pycloudedge-0.1.4.dev3 → pycloudedge-0.1.5.dev0}/pycloudedge.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ cloudedge/constants.py
 cloudedge/exceptions.py
 cloudedge/iot_parameters.py
 cloudedge/logging_config.py
+cloudedge/mqtt.py
 cloudedge/utils.py
 cloudedge/validators.py
 examples/README.md

{pycloudedge-0.1.4.dev3 → pycloudedge-0.1.5.dev0}/pycloudedge.egg-info/requires.txt

@@ -1,5 +1,6 @@
 requests>=2.25.0
 cryptography>=3.4.0
+pycryptodome>=3.15.0
 python-dotenv>=0.19.0
 
 [dev]
@@ -13,3 +14,6 @@ build>=0.7.0
 
 [examples]
 python-dotenv>=0.19.0
+
+[mqtt]
+paho-mqtt>=2.0.0

{pycloudedge-0.1.4.dev3 → pycloudedge-0.1.5.dev0}/pyproject.toml

@@ -34,10 +34,14 @@ classifiers = [
 dependencies = [
     "requests>=2.25.0",
     "cryptography>=3.4.0",
+    "pycryptodome>=3.15.0",
     "python-dotenv>=0.19.0",
 ]
 
 [project.optional-dependencies]
+mqtt = [
+    "paho-mqtt>=2.0.0",
+]
 dev = [
     "pytest>=6.0",
     "pytest-asyncio>=0.18.0",