pyezvizapi 1.0.2.3__py3-none-any.whl → 1.0.4.3__py3-none-any.whl

pyezvizapi/mqtt.py

@@ -83,27 +83,27 @@ class MqttData(TypedDict):
 # Payload decoding helpers
 # ---------------------------------------------------------------------------
 
-# Field names in the comma‑separated ``ext`` payload from EZVIZ.
+# Field names in the comma-separated ``ext`` payload from EZVIZ.
 EXT_FIELD_NAMES: Final[tuple[str, ...]] = (
     "channel_type",
     "time",
     "device_serial",
     "channel_no",
     "alert_type_code",
-    "unused1",
-    "unused2",
-    "unused3",
-    "unused4",
+    "default_pic_url",
+    "media_url_alt1",
+    "media_url_alt2",
+    "resource_type",
     "status_flag",
     "file_id",
     "is_encrypted",
     "picChecksum",
-    "unknown_flag",
-    "unused5",
+    "is_dev_video",
+    "metadata",
     "msgId",
     "image",
     "device_name",
-    "unused6",
+    "reserved",
     "sequence_number",
 )
 
@@ -113,8 +113,10 @@ EXT_INT_FIELDS: Final[frozenset[str]] = frozenset(
         "channel_type",
         "channel_no",
         "alert_type_code",
+        "resource_type",
         "status_flag",
         "is_encrypted",
+        "is_dev_video",
         "sequence_number",
     }
 )
@@ -247,7 +249,7 @@ class MQTTClient:
                 # Stop background thread and disconnect
                 self.mqtt_client.loop_stop()
                 self.mqtt_client.disconnect()
-            except Exception as err:  # noqa: BLE001
+            except (OSError, ValueError, RuntimeError) as err:
                 _LOGGER.debug("MQTT disconnect failed: %s", err)
         # Always attempt to stop push on server side
         self._stop_ezviz_push()
@@ -535,13 +537,17 @@ class MQTTClient:
         """
         broker = self._mqtt_data["push_url"]
 
-        self.mqtt_client = mqtt.Client(
-            callback_api_version=mqtt.CallbackAPIVersion.VERSION1,
-            client_id=self._mqtt_data["mqtt_clientid"],
-            clean_session=clean_session,
-            protocol=mqtt.MQTTv311,
-            transport="tcp",
-        )
+        client_kwargs: dict[str, Any] = {
+            "client_id": self._mqtt_data["mqtt_clientid"],
+            "clean_session": clean_session,
+            "protocol": mqtt.MQTTv311,
+            "transport": "tcp",
+        }
+        callback_api_version = getattr(mqtt, "CallbackAPIVersion", None)
+        if callback_api_version is not None:
+            client_kwargs["callback_api_version"] = callback_api_version.VERSION1
+
+        self.mqtt_client = mqtt.Client(**client_kwargs)
 
         # Bind callbacks
         self.mqtt_client.on_connect = self._on_connect

pyezvizapi/test_cam_rtsp.py

@@ -4,11 +4,14 @@ from __future__ import annotations
 
 import base64
 import hashlib
+import logging
 import socket
 from typing import TypedDict
 
 from .exceptions import AuthTestResultFailed, InvalidHost
 
+_LOGGER = logging.getLogger(__name__)
+
 
 def genmsg_describe(url: str, seq: int, user_agent: str, auth_seq: str) -> str:
     """Generate RTSP DESCRIBE request message."""
@@ -22,6 +25,7 @@ def genmsg_describe(url: str, seq: int, user_agent: str, auth_seq: str) -> str:
 
 class RTSPDetails(TypedDict):
     """Typed structure for RTSP test parameters."""
+
     bufLen: int
     defaultServerIp: str
     defaultServerPort: int
@@ -37,7 +41,11 @@ class TestRTSPAuth:
     _rtsp_details: RTSPDetails
 
     def __init__(
-        self, ip_addr: str, username: str | None = None, password: str | None = None, test_uri: str = ""
+        self,
+        ip_addr: str,
+        username: str | None = None,
+        password: str | None = None,
+        test_uri: str = "",
     ) -> None:
         """Initialize RTSP credential test."""
         self._rtsp_details = RTSPDetails(
@@ -50,7 +58,9 @@ class TestRTSPAuth:
             defaultPassword=password,
         )
 
-    def generate_auth_string(self, realm: bytes, method: str, uri: str, nonce: bytes) -> str:
+    def generate_auth_string(
+        self, realm: bytes, method: str, uri: str, nonce: bytes
+    ) -> str:
         """Generate the HTTP Digest Authorization header value."""
         m_1 = hashlib.md5(
             f"{self._rtsp_details['defaultUsername']}:{realm.decode()}:{self._rtsp_details['defaultPassword']}".encode()
@@ -60,12 +70,12 @@ class TestRTSPAuth:
 
         return (
             "Digest "
-            f"username=\"{self._rtsp_details['defaultUsername']}\", "
-            f"realm=\"{realm.decode()}\", "
+            f'username="{self._rtsp_details["defaultUsername"]}", '
+            f'realm="{realm.decode()}", '
             'algorithm="MD5", '
-            f"nonce=\"{nonce.decode()}\", "
-            f"uri=\"{uri}\", "
-            f"response=\"{response}\""
+            f'nonce="{nonce.decode()}", '
+            f'uri="{uri}", '
+            f'response="{response}"'
         )
 
     def main(self) -> None:
@@ -74,7 +84,10 @@ class TestRTSPAuth:
 
         try:
             session.connect(
-                (self._rtsp_details["defaultServerIp"], self._rtsp_details["defaultServerPort"])
+                (
+                    self._rtsp_details["defaultServerIp"],
+                    self._rtsp_details["defaultServerPort"],
+                )
             )
         except TimeoutError as err:
             raise AuthTestResultFailed("Invalid ip or camera hibernating") from err
@@ -83,24 +96,31 @@ class TestRTSPAuth:
 
         seq: int = 1
 
-        url: str = "rtsp://" + self._rtsp_details["defaultServerIp"] + self._rtsp_details["defaultTestUri"]
+        url: str = (
+            "rtsp://"
+            + self._rtsp_details["defaultServerIp"]
+            + self._rtsp_details["defaultTestUri"]
+        )
 
         # Basic Authorization header
         auth_b64: bytes = base64.b64encode(
-            f"{self._rtsp_details['defaultUsername']}:{self._rtsp_details['defaultPassword']}".encode("ascii")
+            f"{self._rtsp_details['defaultUsername']}:{self._rtsp_details['defaultPassword']}".encode(
+                "ascii"
+            )
         )
         auth_seq: str = "Basic " + auth_b64.decode()
 
-        describe = genmsg_describe(url, seq, self._rtsp_details["defaultUserAgent"], auth_seq)
-        print(describe)
+        describe = genmsg_describe(
+            url, seq, self._rtsp_details["defaultUserAgent"], auth_seq
+        )
+        _LOGGER.debug("RTSP DESCRIBE (basic):\n%s", describe)
         session.send(describe.encode())
         msg1: bytes = session.recv(self._rtsp_details["bufLen"])
         seq += 1
 
         decoded = msg1.decode()
         if "200 OK" in decoded:
-            print(f"Basic auth result: {decoded}")
-            print("Basic Auth test passed. Credentials Valid!")
+            _LOGGER.info("Basic auth result: %s", decoded)
             return
 
         if "Unauthorized" in decoded:
@@ -115,21 +135,23 @@ class TestRTSPAuth:
             end = decoded.find('"', begin + 1)
             nonce: bytes = msg1[begin + 1 : end]
 
-            auth_seq = self.generate_auth_string(realm, "DESCRIBE", self._rtsp_details["defaultTestUri"], nonce)
+            auth_seq = self.generate_auth_string(
+                realm, "DESCRIBE", self._rtsp_details["defaultTestUri"], nonce
+            )
 
-            describe = genmsg_describe(url, seq, self._rtsp_details["defaultUserAgent"], auth_seq)
-            print(describe)
+            describe = genmsg_describe(
+                url, seq, self._rtsp_details["defaultUserAgent"], auth_seq
+            )
+            _LOGGER.debug("RTSP DESCRIBE (digest):\n%s", describe)
             session.send(describe.encode())
             msg1 = session.recv(self._rtsp_details["bufLen"])
             decoded = msg1.decode()
-            print(f"Digest auth result: {decoded}")
+            _LOGGER.info("Digest auth result: %s", decoded)
 
             if "200 OK" in decoded:
-                print("Digest Auth test Passed. Credentials Valid!")
                 return
 
             if "401 Unauthorized" in decoded:
                 raise AuthTestResultFailed("Credentials not valid!!")
 
-        print("Basic Auth test passed. Credentials Valid!")
-# ruff: noqa: T201
+        _LOGGER.info("Basic Auth test passed. Credentials Valid!")

pyezvizapi/test_mqtt.py

@@ -8,6 +8,7 @@ with MFA similar to the main CLI.
 from __future__ import annotations
 
 import argparse
+import base64
 from getpass import getpass
 import json
 import logging
@@ -18,19 +19,60 @@ from typing import Any, cast
 
 from .client import EzvizClient
 from .exceptions import EzvizAuthVerificationCode, PyEzvizError
+from .mqtt import MQTTClient
 
 logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+_LOGGER = logging.getLogger(__name__)
 
 LOG_FILE = Path("mqtt_messages.jsonl")  # JSON Lines format
+RAW_LOG_FILE = Path("mqtt_raw_messages.jsonl")
 
 
 def message_handler(msg: dict[str, Any]) -> None:
     """Handle new MQTT messages by printing and saving them to a file."""
-    print("📩 New MQTT message:", msg)
+    _LOGGER.info("📩 New MQTT message: %s", msg)
     with LOG_FILE.open("a", encoding="utf-8") as f:
         f.write(json.dumps(msg, ensure_ascii=False) + "\n")
 
 
+def _log_raw_payload(payload: bytes) -> None:
+    """Persist the raw MQTT payload to a log file for debugging."""
+    entry: dict[str, Any]
+    try:
+        decoded = payload.decode("utf-8")
+        entry = {"encoding": "utf-8", "payload": decoded}
+    except UnicodeDecodeError:
+        entry = {
+            "encoding": "base64",
+            "payload": base64.b64encode(payload).decode("ascii"),
+        }
+
+    entry["timestamp"] = time.time()
+    _LOGGER.info("🧾 Raw MQTT payload (%s): %s", entry["encoding"], entry["payload"])
+    with RAW_LOG_FILE.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+
+def _enable_raw_logging(mqtt_client: MQTTClient) -> None:
+    """Wrap the internal paho-mqtt callback to capture raw payloads."""
+    if getattr(mqtt_client, "_raw_logging_enabled", False):
+        return
+    paho_client = getattr(mqtt_client, "mqtt_client", None)
+    if paho_client is None:
+        _LOGGER.warning("Unable to enable raw logging: MQTT client not configured yet")
+        return
+
+    original_on_message = paho_client.on_message
+
+    def _raw_logging_wrapper(client: Any, userdata: Any, msg: Any) -> None:
+        _log_raw_payload(getattr(msg, "payload", b""))
+        if original_on_message:
+            original_on_message(client, userdata, msg)
+
+    paho_client.on_message = _raw_logging_wrapper
+    mqtt_client._raw_logging_enabled = True  # type: ignore[attr-defined]  # noqa: SLF001
+
+
 def _load_token_file(path: str | None) -> dict[str, Any] | None:
     if not path:
         return None
@@ -40,7 +82,7 @@ def _load_token_file(path: str | None) -> dict[str, Any] | None:
     try:
         return cast(dict[str, Any], json.loads(p.read_text(encoding="utf-8")))
     except (OSError, json.JSONDecodeError):
-        logging.getLogger(__name__).warning("Failed to read token file: %s", p)
+        _LOGGER.warning("Failed to read token file: %s", p)
         return None
 
 
@@ -50,9 +92,9 @@ def _save_token_file(path: str | None, token: dict[str, Any]) -> None:
     p = Path(path)
     try:
         p.write_text(json.dumps(token, indent=2), encoding="utf-8")
-        logging.getLogger(__name__).info("Saved token to %s", p)
+        _LOGGER.info("Saved token to %s", p)
     except OSError:
-        logging.getLogger(__name__).warning("Failed to save token file: %s", p)
+        _LOGGER.warning("Failed to save token file: %s", p)
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -87,7 +129,7 @@ def main(argv: list[str] | None = None) -> int:
 
     # If no token and missing username/password, prompt interactively
     if not token and (not username or not password):
-        print("No token found. Please enter Ezviz credentials.")
+        _LOGGER.info("No token found. Please enter Ezviz credentials")
         if not username:
             username = input("Username: ")
         if not password:
@@ -107,29 +149,29 @@ def main(argv: list[str] | None = None) -> int:
                 code_int = None
             client.login(sms_code=code_int)
         except PyEzvizError as exp:
-            print(f"Login failed: {exp}")
+            _LOGGER.error("Login failed: %s", exp)
             return 1
 
     # Start MQTT client
     mqtt_client = client.get_mqtt_client(on_message_callback=message_handler)
     mqtt_client.connect()
+    _enable_raw_logging(mqtt_client)
 
     try:
-        print("Listening for MQTT messages... (Ctrl+C to quit)")
+        _LOGGER.info("Listening for MQTT messages... (Ctrl+C to quit)")
         while True:
             time.sleep(1)
     except KeyboardInterrupt:
-        print("\nStopping...")
+        _LOGGER.info("Stopping listener (keyboard interrupt)")
     finally:
         mqtt_client.stop()
-        print("Stopped.")
+        _LOGGER.info("Listener stopped")
 
     if args.save_token and args.token_file:
-        _save_token_file(args.token_file, cast(dict[str, Any], client._token))  # noqa: SLF001
+        _save_token_file(args.token_file, client.export_token())
 
     return 0
 
 
 if __name__ == "__main__":
     sys.exit(main())
-# ruff: noqa: T201