pyezvizapi 1.0.1.6__py3-none-any.whl → 1.0.1.8__py3-none-any.whl

pyezvizapi/test_cam_rtsp.py

@@ -1,149 +1,135 @@
 """Test camera RTSP authentication."""
+
+from __future__ import annotations
+
 import base64
 import hashlib
 import socket
+from typing import TypedDict
 
 from .exceptions import AuthTestResultFailed, InvalidHost
 
 
-def genmsg_describe(url, seq, user_agent, auth_seq):
-    """Generate RTSP describe message."""
-    msg_ret = "DESCRIBE " + url + " RTSP/1.0\r\n"
-    msg_ret += "CSeq: " + str(seq) + "\r\n"
-    msg_ret += "Authorization: " + auth_seq + "\r\n"
-    msg_ret += "User-Agent: " + user_agent + "\r\n"
-    msg_ret += "Accept: application/sdp\r\n"
-    msg_ret += "\r\n"
+def genmsg_describe(url: str, seq: int, user_agent: str, auth_seq: str) -> str:
+    """Generate RTSP DESCRIBE request message."""
+    msg_ret = f"DESCRIBE {url} RTSP/1.0\r\n"
+    msg_ret += f"CSeq: {seq}\r\n"
+    msg_ret += f"Authorization: {auth_seq}\r\n"
+    msg_ret += f"User-Agent: {user_agent}\r\n"
+    msg_ret += "Accept: application/sdp\r\n\r\n"
     return msg_ret
 
 
+class RTSPDetails(TypedDict):
+    """Typed structure for RTSP test parameters."""
+    bufLen: int
+    defaultServerIp: str
+    defaultServerPort: int
+    defaultTestUri: str
+    defaultUserAgent: str
+    defaultUsername: str | None
+    defaultPassword: str | None
+
+
 class TestRTSPAuth:
-    """Test RTSP credentials."""
+    """Test RTSP credentials against an RTSP server."""
+
+    _rtsp_details: RTSPDetails
 
     def __init__(
-        self,
-        ip_addr,
-        username=None,
-        password=None,
-        test_uri="",
+        self, ip_addr: str, username: str | None = None, password: str | None = None, test_uri: str = ""
     ) -> None:
         """Initialize RTSP credential test."""
-        self._rtsp_details = {
-            "bufLen": 1024,
-            "defaultServerIp": ip_addr,
-            "defaultServerPort": 554,
-            "defaultTestUri": test_uri,
-            "defaultUserAgent": "RTSP Client",
-            "defaultUsername": username,
-            "defaultPassword": password,
-        }
-
-    def generate_auth_string(self, realm, method, uri, nonce):
-        """Generate digest auth string."""
-        map_return_info = {}
+        self._rtsp_details = RTSPDetails(
+            bufLen=1024,
+            defaultServerIp=ip_addr,
+            defaultServerPort=554,
+            defaultTestUri=test_uri,
+            defaultUserAgent="RTSP Client",
+            defaultUsername=username,
+            defaultPassword=password,
+        )
+
+    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']}:"
-            f"{realm.decode()}:"
-            f"{self._rtsp_details['defaultPassword']}".encode()
+            f"{self._rtsp_details['defaultUsername']}:{realm.decode()}:{self._rtsp_details['defaultPassword']}".encode()
         ).hexdigest()
         m_2 = hashlib.md5(f"{method}:{uri}".encode()).hexdigest()
-        response = hashlib.md5(f"{m_1}:{nonce}:{m_2}".encode()).hexdigest()
+        response = hashlib.md5(f"{m_1}:{nonce.decode()}:{m_2}".encode()).hexdigest()
 
-        map_return_info = (
-            f"Digest "
+        return (
+            "Digest "
             f"username=\"{self._rtsp_details['defaultUsername']}\", "
-            f'realm="{realm.decode()}", '
-            f'algorithm="MD5", '
-            f'nonce="{nonce.decode()}", '
-            f'uri="{uri}", '
-            f'response="{response}"'
+            f"realm=\"{realm.decode()}\", "
+            'algorithm="MD5", '
+            f"nonce=\"{nonce.decode()}\", "
+            f"uri=\"{uri}\", "
+            f"response=\"{response}\""
         )
-        return map_return_info
 
-    def main(self):
-        """Start main method."""
-        session = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    def main(self) -> None:
+        """Open RTSP socket, try Basic and then Digest auth for DESCRIBE."""
+        session: socket.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
         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
-
         except (socket.gaierror, ConnectionRefusedError) as err:
             raise InvalidHost("Invalid IP or Hostname") from err
 
-        seq = 1
+        seq: int = 1
 
-        url = (
-            "rtsp://"
-            + self._rtsp_details["defaultServerIp"]
-            + self._rtsp_details["defaultTestUri"]
-        )
-
-        auth_seq = base64.b64encode(
-            f"{self._rtsp_details['defaultUsername']}:"
-            f"{self._rtsp_details['defaultPassword']}".encode("ascii")
-        )
-        auth_seq = "Basic " + auth_seq.decode()
+        url: str = "rtsp://" + self._rtsp_details["defaultServerIp"] + self._rtsp_details["defaultTestUri"]
 
-        print(
-            genmsg_describe(url, seq, self._rtsp_details["defaultUserAgent"], auth_seq)
+        # Basic Authorization header
+        auth_b64: bytes = base64.b64encode(
+            f"{self._rtsp_details['defaultUsername']}:{self._rtsp_details['defaultPassword']}".encode("ascii")
         )
-        session.send(
-            genmsg_describe(
-                url, seq, self._rtsp_details["defaultUserAgent"], auth_seq
-            ).encode()
-        )
-        msg1 = session.recv(self._rtsp_details["bufLen"])
-        seq = seq + 1
-
-        if msg1.decode().find("200 OK") > 1:
-            print(f"Basic auth result: {msg1.decode()}")
-            return print("Basic Auth test passed. Credentials Valid!")
-
-        if msg1.decode().find("Unauthorized") > 1:
-            # Basic failed, doing new DESCRIBE with digest authentication.
-            start = msg1.decode().find("realm")
-            begin = msg1.decode().find('"', start)
-            end = msg1.decode().find('"', begin + 1)
-            realm = msg1[begin + 1 : end]
-
-            start = msg1.decode().find("nonce")
-            begin = msg1.decode().find('"', start)
-            end = msg1.decode().find('"', begin + 1)
-            nonce = msg1[begin + 1 : end]
-
-            auth_seq = self.generate_auth_string(
-                realm,
-                "DESCRIBE",
-                self._rtsp_details["defaultTestUri"],
-                nonce,
-            )
-
-            print(
-                genmsg_describe(
-                    url, seq, self._rtsp_details["defaultUserAgent"], auth_seq
-                )
-            )
-
-            session.send(
-                genmsg_describe(
-                    url, seq, self._rtsp_details["defaultUserAgent"], auth_seq
-                ).encode()
-            )
+        auth_seq: str = "Basic " + auth_b64.decode()
+
+        describe = genmsg_describe(url, seq, self._rtsp_details["defaultUserAgent"], auth_seq)
+        print(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!")
+            return
+
+        if "Unauthorized" in decoded:
+            # Basic failed, do new DESCRIBE with digest authentication.
+            start = decoded.find("realm")
+            begin = decoded.find('"', start)
+            end = decoded.find('"', begin + 1)
+            realm: bytes = msg1[begin + 1 : end]
+
+            start = decoded.find("nonce")
+            begin = decoded.find('"', start)
+            end = decoded.find('"', begin + 1)
+            nonce: bytes = msg1[begin + 1 : end]
+
+            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)
+            session.send(describe.encode())
             msg1 = session.recv(self._rtsp_details["bufLen"])
-            print(f"Digest auth result: {msg1.decode()}")
+            decoded = msg1.decode()
+            print(f"Digest auth result: {decoded}")
 
-            if msg1.decode().find("200 OK") > 1:
-                return print("Digest Auth test Passed. Credentials Valid!")
+            if "200 OK" in decoded:
+                print("Digest Auth test Passed. Credentials Valid!")
+                return
 
-            if msg1.decode().find("401 Unauthorized") > 1:
+            if "401 Unauthorized" in decoded:
                 raise AuthTestResultFailed("Credentials not valid!!")
 
-        return print("Basic Auth test passed. Credentials Valid!")
+        print("Basic Auth test passed. Credentials Valid!")
+# ruff: noqa: T201

pyezvizapi/test_mqtt.py

@@ -0,0 +1,135 @@
+"""MQTT test module.
+
+Run a simple MQTT listener using either a saved token file
+(`--token-file ezviz_token.json`) or by prompting for username/password
+with MFA similar to the main CLI.
+"""
+
+from __future__ import annotations
+
+import argparse
+from getpass import getpass
+import json
+import logging
+from pathlib import Path
+import sys
+import time
+from typing import Any, cast
+
+from .client import EzvizClient
+from .exceptions import EzvizAuthVerificationCode, PyEzvizError
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+
+LOG_FILE = Path("mqtt_messages.jsonl")  # JSON Lines format
+
+
+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)
+    with LOG_FILE.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(msg, ensure_ascii=False) + "\n")
+
+
+def _load_token_file(path: str | None) -> dict[str, Any] | None:
+    if not path:
+        return None
+    p = Path(path)
+    if not p.exists():
+        return 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)
+        return None
+
+
+def _save_token_file(path: str | None, token: dict[str, Any]) -> None:
+    if not path:
+        return
+    p = Path(path)
+    try:
+        p.write_text(json.dumps(token, indent=2), encoding="utf-8")
+        logging.getLogger(__name__).info("Saved token to %s", p)
+    except OSError:
+        logging.getLogger(__name__).warning("Failed to save token file: %s", p)
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry point for testing MQTT messages."""
+    parser = argparse.ArgumentParser(prog="test_mqtt")
+    parser.add_argument("-u", "--username", required=False, help="Ezviz username")
+    parser.add_argument("-p", "--password", required=False, help="Ezviz password")
+    parser.add_argument(
+        "-r",
+        "--region",
+        required=False,
+        default="apiieu.ezvizlife.com",
+        help="Ezviz API region",
+    )
+    parser.add_argument(
+        "--token-file",
+        type=str,
+        default="ezviz_token.json",
+        help="Path to JSON token file (default: ezviz_token.json)",
+    )
+    parser.add_argument(
+        "--save-token",
+        action="store_true",
+        help="Save token to --token-file after successful login",
+    )
+    args = parser.parse_args(argv)
+
+    token = _load_token_file(args.token_file)
+
+    username = args.username
+    password = args.password
+
+    # 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.")
+        if not username:
+            username = input("Username: ")
+        if not password:
+            password = getpass("Password: ")
+
+    client = EzvizClient(username, password, args.region, token=token)
+
+    # Login if we have credentials (to refresh session and populate service URLs)
+    if username and password:
+        try:
+            client.login()
+        except EzvizAuthVerificationCode:
+            mfa_code = input("MFA code required, please input MFA code.\n")
+            try:
+                code_int = int(mfa_code.strip())
+            except ValueError:
+                code_int = None
+            client.login(sms_code=code_int)
+        except PyEzvizError as exp:
+            print(f"Login failed: {exp}")
+            return 1
+
+    # Start MQTT client
+    mqtt_client = client.get_mqtt_client(on_message_callback=message_handler)
+    mqtt_client.connect()
+
+    try:
+        print("Listening for MQTT messages... (Ctrl+C to quit)")
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("\nStopping...")
+    finally:
+        mqtt_client.stop()
+        print("Stopped.")
+
+    if args.save_token and args.token_file:
+        _save_token_file(args.token_file, cast(dict[str, Any], client._token))  # noqa: SLF001
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+# ruff: noqa: T201

pyezvizapi/utils.py

@@ -6,6 +6,7 @@ from hashlib import md5
 import json
 import logging
 from typing import Any
+import uuid
 
 from Crypto.Cipher import AES
 
@@ -61,10 +62,12 @@ def fetch_nested_value(data: Any, keys: list, default_value: Any = None) -> Any:
     try:
         for key in keys:
             data = data[key]
-        return data
+
     except (KeyError, TypeError):
         return default_value
 
+    return data
+
 
 def decrypt_image(input_data: bytes, password: str) -> bytes:
     """Decrypts image data with provided password.
@@ -80,7 +83,6 @@ def decrypt_image(input_data: bytes, password: str) -> bytes:
         bytes: Decrypted image data
 
     """
-
     if len(input_data) < 48:
         raise PyEzvizError("Invalid image data")
 
@@ -162,3 +164,27 @@ def deep_merge(dict1: Any, dict2: Any) -> Any:
             merged[key] = dict2[key]
 
     return merged
+
+
+def generate_unique_code() -> str:
+    """Generate a deterministic, platform-agnostic unique code for the current host.
+
+    This function retrieves the host's MAC address using Python's standard
+    `uuid.getnode()` (works on Windows, Linux, macOS), converts it to a
+    canonical string representation, and then hashes it using MD5 to produce
+    a fixed-length hexadecimal string.
+
+    Returns:
+        str: A 32-character hexadecimal string uniquely representing
+        the host's MAC address. For example:
+        'a94e6756hghjgfghg49e0f310d9e44a'.
+
+    Notes:
+        - The output is deterministic: the same machine returns the same code.
+        - If the MAC address changes (e.g., different network adapter),
+          the output will change.
+        - MD5 is used here only for ID generation, not for security.
+    """
+    mac_int = uuid.getnode()
+    mac_str = ":".join(f"{(mac_int >> i) & 0xFF:02x}" for i in range(40, -1, -8))
+    return md5(mac_str.encode("utf-8")).hexdigest()

{pyezvizapi-1.0.1.6.dist-info → pyezvizapi-1.0.1.8.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: pyezvizapi
-Version: 1.0.1.6
+Version: 1.0.1.8
 Summary: Pilot your Ezviz cameras
 Home-page: https://github.com/RenierM26/pyEzvizApi/
 Author: Renier Moorcroft
 Author-email: RenierM26@users.github.com
 License: Apache Software License 2.0
-Requires-Python: >=3.6
+Requires-Python: >=3.11
 License-File: LICENSE
 License-File: LICENSE.md
 Requires-Dist: requests

pyezvizapi-1.0.1.8.dist-info/RECORD

@@ -0,0 +1,21 @@
+pyezvizapi/__init__.py,sha256=IDnIN_nfIISVwuy0cVBh4wspgAav6MuOJCQGajjyU3g,1881
+pyezvizapi/__main__.py,sha256=SeV954H-AV-U1thNxRd7rWTGtSlfWyNzdrjF8gikYus,20777
+pyezvizapi/api_endpoints.py,sha256=rk6VinLVCn-B6DxnhfV79liplNpgUsipNbTEa_MRVwU,2755
+pyezvizapi/camera.py,sha256=HcJPUXQnYEAVqh6alphuRiMl6al28C9JORP6LO3m_es,24927
+pyezvizapi/cas.py,sha256=ISmb-eTPuacI10L87lULbQ-oDMBuygO7Tf-s9f-tvYE,5995
+pyezvizapi/client.py,sha256=dcHAsdtfSTkVCrkaEZKpFggDXX4t5debpuxc76sOy-k,71267
+pyezvizapi/constants.py,sha256=R0zGg8Rv59An36dSXQLl3WU7VbpTbpo2comk9VJc68k,12535
+pyezvizapi/exceptions.py,sha256=8rmxEUQdrziqMe-M1SeeRd0HtP2IDQ2xpJVj7wvOQyo,976
+pyezvizapi/light_bulb.py,sha256=9wgycG3dTvBbrsxQjQnXal-GA8VXPsIN1m-CTtRh8i0,7797
+pyezvizapi/models.py,sha256=NQzwTP0yEe2IWU-Vc6nAn87xulpTuo0MX2Rcf0WxifA,4176
+pyezvizapi/mqtt.py,sha256=TxIjg2Xk6Qh4LWQQXKS6vpgLj2Rl2KOkDRwaz46PGUU,22367
+pyezvizapi/test_cam_rtsp.py,sha256=WGSM5EiOTl_r1mWHoMb7bXHm_BCn1P9X_669YQ38r6k,4903
+pyezvizapi/test_mqtt.py,sha256=Orn-fwZPJIE4G5KROMX0MRAkLwU6nLb9LUtXyb2ZCQs,4147
+pyezvizapi/utils.py,sha256=o342o3LI9eP8qla1vXM2rqlVbdTiLK0dAqrkyUSXpg8,5939
+pyezvizapi-1.0.1.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyezvizapi-1.0.1.8.dist-info/licenses/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyezvizapi-1.0.1.8.dist-info/METADATA,sha256=7t6tdY_1RMQ524_vV-Z5zcMZr5hPeK7h8PIYXsrsUoA,695
+pyezvizapi-1.0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyezvizapi-1.0.1.8.dist-info/entry_points.txt,sha256=_BSJ3eNb2H_AZkRdsv1s4mojqWn3N7m503ujvg1SudA,56
+pyezvizapi-1.0.1.8.dist-info/top_level.txt,sha256=gMZTelIi8z7pXyTCQLLaIkxVRrDQ_lS2NEv0WgfHrHs,11
+pyezvizapi-1.0.1.8.dist-info/RECORD,,

pyezvizapi-1.0.1.6.dist-info/RECORD

@@ -1,19 +0,0 @@
-pyezvizapi/__init__.py,sha256=yWITfZOi5zvKblfaeB2ft-wXYmZ2NviYVq_tsK8YkSk,1334
-pyezvizapi/__main__.py,sha256=OsawbYa-eoLUTOMr4xWeryq4sDzs09WL9GELKQTbda8,16396
-pyezvizapi/api_endpoints.py,sha256=rk6VinLVCn-B6DxnhfV79liplNpgUsipNbTEa_MRVwU,2755
-pyezvizapi/camera.py,sha256=BpmLySbnWWEKimSwgjx_cB60Q-6dbgdY-NA--NzUvps,11486
-pyezvizapi/cas.py,sha256=d31ZflYSD9P40MnsNRNZbT0HVLvlnHokKpLbdAjWQ74,5631
-pyezvizapi/client.py,sha256=lak8r1Src1R57dQYwzVDq7NRt1iIOdkESyuR2FWqmRQ,85563
-pyezvizapi/constants.py,sha256=jjLO-Ne9jq9m9_giYB4rnPXDZKkzKhesVXBqP1B3-00,12304
-pyezvizapi/exceptions.py,sha256=28lLyM0ILTRHgWqr9D-DqqKFXx7POuF0WAZctdC8Kbc,735
-pyezvizapi/light_bulb.py,sha256=ADLrPZ6NL4vANzmohU63QuD9qVGkKHkX9C0o7Evbv-A,5730
-pyezvizapi/mqtt.py,sha256=Y4X99Z0Avm32SE8vog7CNsv6tGUPmPYUZUgPDGS0QJA,7866
-pyezvizapi/test_cam_rtsp.py,sha256=w7GPcYIeK78TxL8zFDihdGSDQNWcYrurwZOr6uFzzgo,4902
-pyezvizapi/utils.py,sha256=5J10o3h-y8prWDvl3LSAF-9wS1jBgBMg5cpAEebcuSM,4936
-pyezvizapi-1.0.1.6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyezvizapi-1.0.1.6.dist-info/licenses/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyezvizapi-1.0.1.6.dist-info/METADATA,sha256=GAvczQGW5LSpRKQg5jCaExw9KM4GcvqKa0L9WYWvMxc,694
-pyezvizapi-1.0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyezvizapi-1.0.1.6.dist-info/entry_points.txt,sha256=_BSJ3eNb2H_AZkRdsv1s4mojqWn3N7m503ujvg1SudA,56
-pyezvizapi-1.0.1.6.dist-info/top_level.txt,sha256=gMZTelIi8z7pXyTCQLLaIkxVRrDQ_lS2NEv0WgfHrHs,11
-pyezvizapi-1.0.1.6.dist-info/RECORD,,