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

pyezvizapi/utils.py

@@ -2,22 +2,49 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterable, Iterator
 import datetime
 from hashlib import md5
 import json
 import logging
 import re as _re
 from typing import Any
-import uuid
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 from Crypto.Cipher import AES
 
+from .constants import HIK_ENCRYPTION_HEADER
 from .exceptions import PyEzvizError
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def coerce_int(value: Any) -> int | None:
+    """Best-effort coercion to int for mixed payloads."""
+
+    if isinstance(value, bool):
+        return int(value)
+
+    if isinstance(value, (int, float)):
+        return int(value)
+
+    try:
+        return int(str(value))
+    except (TypeError, ValueError):
+        return None
+
+
+def decode_json(value: Any) -> Any:
+    """Decode a JSON string when possible, otherwise return the original value."""
+
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except (TypeError, ValueError):
+            return None
+    return value
+
+
 def convert_to_dict(data: Any) -> Any:
     """Recursively convert a string representation of a dictionary to a dictionary."""
     if isinstance(data, dict):
@@ -36,18 +63,64 @@ def convert_to_dict(data: Any) -> Any:
 
 def string_to_list(data: Any, separator: str = ",") -> Any:
     """Convert a string representation of a list to a list."""
-    if isinstance(data, str):
-        if separator in data:
-            try:
-                # Attempt to convert the string into a list
-                return data.split(separator)
+    if isinstance(data, str) and separator in data:
+        try:
+            # Attempt to convert the string into a list
+            return data.split(separator)
 
-            except AttributeError:
-                return data
+        except AttributeError:
+            return data
 
     return data
 
 
+PathComponent = str | int
+WILDCARD_STEP = "*"
+_MISSING = object()
+MILLISECONDS_THRESHOLD = 1e11
+
+
+def iter_nested(data: Any, path: Iterable[PathComponent]) -> Iterator[Any]:
+    """Yield values reachable by following a dotted path with optional wildcards."""
+
+    current: list[Any] = [data]
+
+    for step in path:
+        next_level: list[Any] = []
+        for candidate in current:
+            if step == WILDCARD_STEP:
+                if isinstance(candidate, dict):
+                    next_level.extend(candidate.values())
+                elif isinstance(candidate, (list, tuple)):
+                    next_level.extend(candidate)
+                continue
+
+            if isinstance(candidate, dict) and step in candidate:
+                next_level.append(candidate[step])
+                continue
+
+            if (
+                isinstance(candidate, (list, tuple))
+                and isinstance(step, int)
+                and -len(candidate) <= step < len(candidate)
+            ):
+                next_level.append(candidate[step])
+
+        current = next_level
+        if not current:
+            break
+
+    yield from current
+
+
+def first_nested(
+    data: Any, path: Iterable[PathComponent], default: Any = None
+) -> Any:
+    """Return the first value produced by iter_nested or ``default``."""
+
+    return next(iter_nested(data, path), default)
+
+
 def fetch_nested_value(data: Any, keys: list, default_value: Any = None) -> Any:
     """Fetch the value corresponding to the given nested keys in a dictionary.
 
@@ -62,14 +135,8 @@ def fetch_nested_value(data: Any, keys: list, default_value: Any = None) -> Any:
         The value corresponding to the nested keys or the default value.
 
     """
-    try:
-        for key in keys:
-            data = data[key]
-
-    except (KeyError, TypeError):
-        return default_value
-
-    return data
+    value = first_nested(data, keys, _MISSING)
+    return default_value if value is _MISSING else value
 
 
 def decrypt_image(input_data: bytes, password: str) -> bytes:
@@ -86,37 +153,102 @@ def decrypt_image(input_data: bytes, password: str) -> bytes:
         bytes: Decrypted image data
 
     """
-    if len(input_data) < 48:
+    header_len = len(HIK_ENCRYPTION_HEADER)
+    min_length = header_len + 32  # header + md5 hash
+
+    if len(input_data) < min_length:
         raise PyEzvizError("Invalid image data")
 
-    # check header
-    if input_data[:16] != b"hikencodepicture":
-        _LOGGER.debug("Image header doesn't contain 'hikencodepicture'")
+    header_index = input_data.find(HIK_ENCRYPTION_HEADER)
+    if header_index == -1:
+        _LOGGER.debug("Image header doesn't contain %s", HIK_ENCRYPTION_HEADER)
         return input_data
 
-    file_hash = input_data[16:48]
+    if header_index:
+        _LOGGER.debug("Image header found at offset %s, trimming preamble", header_index)
+        input_data = input_data[header_index:]
+        if len(input_data) < min_length:
+            raise PyEzvizError("Invalid image data after trimming preamble")
+
+    hash_end = header_len + 32
+    blocks = _split_encrypted_blocks(input_data, header_len, min_length)
+    if not blocks:
+        raise PyEzvizError("Invalid image data")
+
+    decrypted_parts = [
+        _decrypt_single_block(block, password, header_len, hash_end) for block in blocks
+    ]
+    if len(decrypted_parts) > 1:
+        _LOGGER.debug("Decrypted %s concatenated image blocks", len(decrypted_parts))
+    return b"".join(decrypted_parts)
+
+
+def _split_encrypted_blocks(
+    data: bytes, header_len: int, min_length: int
+) -> list[bytes]:
+    """Split concatenated hikencodepicture segments into individual blocks."""
+    blocks: list[bytes] = []
+    cursor = 0
+    data_len = len(data)
+
+    while cursor <= data_len - min_length:
+        if data[cursor : cursor + header_len] != HIK_ENCRYPTION_HEADER:
+            next_header = data.find(HIK_ENCRYPTION_HEADER, cursor + 1)
+            if next_header == -1:
+                break
+            cursor = next_header
+            continue
+
+        next_header = data.find(HIK_ENCRYPTION_HEADER, cursor + header_len)
+        block = data[cursor : next_header if next_header != -1 else data_len]
+        if len(block) < min_length:
+            break
+        blocks.append(block)
+        if next_header == -1:
+            break
+        cursor = next_header
+
+    return blocks
+
+
+def _decrypt_single_block(
+    block: bytes, password: str, header_len: int, hash_end: int
+) -> bytes:
+    """Decrypt a single hikencodepicture block."""
+    file_hash = block[header_len:hash_end]
     passwd_hash = md5(str.encode(md5(str.encode(password)).hexdigest())).hexdigest()
     if file_hash != str.encode(passwd_hash):
         raise PyEzvizError("Invalid password")
 
+    ciphertext = block[hash_end:]
+    if not ciphertext:
+        raise PyEzvizError("Missing ciphertext payload")
+
+    remainder = len(ciphertext) % AES.block_size
+    if remainder:
+        _LOGGER.debug(
+            "Ciphertext not aligned to 16 bytes; trimming %s trailing bytes", remainder
+        )
+        ciphertext = ciphertext[:-remainder]
+    if not ciphertext:
+        raise PyEzvizError("Ciphertext too short after alignment adjustment")
+
     key = str.encode(password.ljust(16, "\u0000")[:16])
     iv_code = bytes([48, 49, 50, 51, 52, 53, 54, 55, 0, 0, 0, 0, 0, 0, 0, 0])
     cipher = AES.new(key, AES.MODE_CBC, iv_code)
 
-    next_chunk = b""
-    output_data = b""
-    finished = False
-    i = 48  # offset hikencodepicture + hash
     chunk_size = 1024 * AES.block_size
-    while not finished:
-        chunk, next_chunk = next_chunk, cipher.decrypt(input_data[i : i + chunk_size])
-        if len(next_chunk) == 0:
-            padding_length = chunk[-1]
-            chunk = chunk[:-padding_length]
-            finished = True
-        output_data += chunk
-        i += chunk_size
-    return output_data
+    output_data = bytearray()
+
+    for start in range(0, len(ciphertext), chunk_size):
+        block_chunk = cipher.decrypt(ciphertext[start : start + chunk_size])
+        if start + chunk_size >= len(ciphertext):
+            padding_length = block_chunk[-1]
+            block_chunk = block_chunk[:-padding_length]
+        output_data.extend(block_chunk)
+
+    return bytes(output_data)
+
 
 
 def return_password_hash(password: str) -> str:
@@ -169,34 +301,11 @@ def deep_merge(dict1: Any, dict2: Any) -> Any:
     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()
-
-
 # ---------------------------------------------------------------------------
 # Time helpers for alarm/motion handling
 # ---------------------------------------------------------------------------
 
+
 def normalize_alarm_time(
     last_alarm: dict[str, Any], tzinfo: datetime.tzinfo
 ) -> tuple[datetime.datetime | None, datetime.datetime | None, str | None]:
@@ -228,7 +337,7 @@ def normalize_alarm_time(
     if epoch is not None:
         try:
             ts = float(epoch if not isinstance(epoch, str) else float(epoch))
-            if ts > 1e11:  # milliseconds
+            if ts > MILLISECONDS_THRESHOLD:  # milliseconds
                 ts /= 1000.0
             event_utc = datetime.datetime.fromtimestamp(ts, tz=datetime.UTC)
             alarm_dt_local = event_utc.astimezone(tzinfo)
@@ -241,14 +350,15 @@ def normalize_alarm_time(
                         raw_norm, "%Y-%m-%d %H:%M:%S"
                     ).replace(tzinfo=tzinfo)
                     diff = abs(
-                        (event_utc - dt_str_local.astimezone(datetime.UTC)).total_seconds()
+                        (
+                            event_utc - dt_str_local.astimezone(datetime.UTC)
+                        ).total_seconds()
                     )
                     if diff > 120:
                         # Reinterpret epoch as local clock time in camera tz
-                        naive_utc = (
-                            datetime.datetime.fromtimestamp(ts, tz=datetime.UTC)
-                            .replace(tzinfo=None)
-                        )
+                        naive_utc = datetime.datetime.fromtimestamp(
+                            ts, tz=datetime.UTC
+                        ).replace(tzinfo=None)
                         event_local_reint = naive_utc.replace(tzinfo=tzinfo)
                         alarm_dt_local = event_local_reint
                         alarm_dt_utc = event_local_reint.astimezone(datetime.UTC)
@@ -266,9 +376,9 @@ def normalize_alarm_time(
     if raw_time_str:
         raw = raw_time_str.replace("Today", str(now_local.date()))
         try:
-            alarm_dt_local = datetime.datetime.strptime(raw, "%Y-%m-%d %H:%M:%S").replace(
-                tzinfo=tzinfo
-            )
+            alarm_dt_local = datetime.datetime.strptime(
+                raw, "%Y-%m-%d %H:%M:%S"
+            ).replace(tzinfo=tzinfo)
             alarm_dt_utc = alarm_dt_local.astimezone(datetime.UTC)
             alarm_str = alarm_dt_local.strftime("%Y-%m-%d %H:%M:%S")
         except ValueError:
@@ -294,10 +404,11 @@ def compute_motion_from_alarm(
     now_local = datetime.datetime.now(tz=tzinfo).replace(microsecond=0)
     now_utc = datetime.datetime.now(tz=datetime.UTC).replace(microsecond=0)
 
-    if alarm_dt_utc is not None:
-        delta = now_utc - alarm_dt_utc
-    else:
-        delta = now_local - alarm_dt_local
+    delta = (
+        now_utc - alarm_dt_utc
+        if alarm_dt_utc is not None
+        else now_local - alarm_dt_local
+    )
 
     seconds = float(delta.total_seconds())
     if seconds < 0:

pyezvizapi-1.0.4.3.dist-info/METADATA

@@ -0,0 +1,286 @@
+Metadata-Version: 2.4
+Name: pyezvizapi
+Version: 1.0.4.3
+Summary: EZVIZ API client for Home Assistant and CLI
+Home-page: https://github.com/RenierM26/pyEzvizApi/
+Author: Renier Moorcroft
+Author-email: RenierM26@users.github.com
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: LICENSE.md
+Requires-Dist: requests
+Requires-Dist: xmltodict
+Requires-Dist: pycryptodome
+Requires-Dist: paho-mqtt
+Requires-Dist: pandas
+Provides-Extra: dev
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Ezviz PyPi
+
+![Upload Python Package](https://github.com/RenierM26/pyEzvizApi/workflows/Upload%20Python%20Package/badge.svg)
+
+## Overview
+
+Pilot your Ezviz cameras (and light bulbs) with this module. It is used by:
+
+- The official Ezviz integration in Home Assistant
+- The EZVIZ (Beta) custom integration for Home Assistant
+
+You can also use it directly from the command line for quick checks and scripting.
+
+## Features
+
+- Inspect device and connection status in table or JSON form
+- Control cameras: PTZ, privacy/sleep/audio/IR/state LEDs, alarm settings
+- Control light bulbs: toggle, status, brightness and color temperature
+- Dump raw pagelist and device infos JSON for exploration/debugging
+- Reuse a saved session token (no credentials needed after first login)
+
+## Install
+
+From PyPI:
+
+```bash
+pip install pyezvizapi
+```
+
+After installation, a `pyezvizapi` command is available on your PATH.
+
+### Dependencies (development/local usage)
+
+If you are running from a clone of this repository or using the helper scripts directly, ensure these packages are available:
+
+```bash
+pip install requests paho-mqtt pycryptodome pandas
+```
+
+## Quick Start
+
+```bash
+# See available commands and options
+pyezvizapi --help
+
+# First-time login and save token for reuse
+pyezvizapi -u YOUR_EZVIZ_USERNAME -p YOUR_EZVIZ_PASSWORD --save-token devices status
+
+# Subsequent runs can reuse the saved token (no credentials needed)
+pyezvizapi devices status --json
+```
+
+## CLI Authentication
+
+- Username/password: `-u/--username` and `-p/--password`
+- Token file: `--token-file` (defaults to `ezviz_token.json` in the current directory)
+- Save token: `--save-token` writes the current token after login
+- MFA: The CLI prompts for a code if required by your account
+- Region: `-r/--region` overrides the default region (`apiieu.ezvizlife.com`)
+
+Examples:
+
+```bash
+# First-time login and save token locally
+pyezvizapi -u YOUR_EZVIZ_USERNAME -p YOUR_EZVIZ_PASSWORD --save-token devices status
+
+# Reuse saved token (no credentials)
+pyezvizapi devices status --json
+```
+
+## Output Modes
+
+- Default: human-readable tables (for list/status views)
+- JSON: add `--json` for easy parsing and editor-friendly exploration
+
+## CLI Commands
+
+All commands are subcommands of the module runner:
+
+```bash
+pyezvizapi <command> [options]
+```
+
+### devices
+
+- Actions: `device`, `status`, `switch`, `connection`
+- Examples:
+
+```bash
+# Table view
+pyezvizapi devices status
+
+# JSON view
+pyezvizapi devices status --json
+```
+
+Sample table columns include:
+
+```
+name | status | device_category | device_sub_category | sleep | privacy | audio | ir_led | state_led | local_ip | local_rtsp_port | battery_level | alarm_schedules_enabled | alarm_notify | Motion_Trigger
+```
+
+The CLI also computes a `switch_flags` map for each device (all switch states by name, e.g. `privacy`, `sleep`, `sound`, `infrared_light`, `light`, etc.).
+
+### camera
+
+Requires `--serial`.
+
+- Actions: `status`, `move`, `move_coords`, `unlock-door`, `unlock-gate`, `switch`, `alarm`, `select`
+- Examples:
+
+```bash
+# Camera status
+pyezvizapi camera --serial ABC123 status
+
+# PTZ move
+pyezvizapi camera --serial ABC123 move --direction up --speed 5
+
+# Move by coordinates
+pyezvizapi camera --serial ABC123 move_coords --x 0.4 --y 0.6
+
+# Switch setters
+pyezvizapi camera --serial ABC123 switch --switch privacy --enable 1
+
+# Alarm settings (push notify, sound level, do-not-disturb)
+pyezvizapi camera --serial ABC123 alarm --notify 1 --sound 2 --do_not_disturb 0
+
+# Battery camera work mode
+pyezvizapi camera --serial ABC123 select --battery_work_mode POWER_SAVE
+```
+
+### devices_light
+
+- Actions: `status`
+- Example:
+
+```bash
+pyezvizapi devices_light status
+```
+
+### home_defence_mode
+
+Set global defence mode for the account/home.
+
+```bash
+pyezvizapi home_defence_mode --mode HOME_MODE
+```
+
+### mqtt
+
+Connect to Ezviz MQTT push notifications using the current session token. Use `--debug` to see connection details.
+
+```bash
+pyezvizapi mqtt
+```
+
+#### MQTT push test script (standalone)
+
+For quick experimentation, a small helper script is included which can use a saved token file or prompt for credentials with MFA and save the session token:
+
+```bash
+# With a previously saved token file
+python config/custom_components/ezviz_cloud/pyezvizapi/test_mqtt.py --token-file ezviz_token.json
+
+# Interactive login, then save token for next time
+python config/custom_components/ezviz_cloud/pyezvizapi/test_mqtt.py --save-token
+
+# Explicit credentials (not recommended for shared terminals)
+python config/custom_components/ezviz_cloud/pyezvizapi/test_mqtt.py -u USER -p PASS --save-token
+```
+
+### pagelist
+
+Dump the complete raw pagelist JSON. Great for exploring unknown fields in an editor (e.g. Notepad++).
+
+```bash
+pyezvizapi pagelist > pagelist.json
+```
+
+### device_infos
+
+Dump the processed device infos mapping (what the integration consumes). Optionally filter to one serial:
+
+```bash
+# All devices
+pyezvizapi device_infos > device_infos.json
+
+# Single device
+pyezvizapi device_infos --serial ABC123 > ABC123.json
+```
+
+## Remote door and gate unlock (CS-HPD7)
+
+```bash
+pyezvizapi camera --serial BAXXXXXXX-BAYYYYYYY unlock-door
+pyezvizapi camera --serial BAXXXXXXX-BAYYYYYYY unlock-gate
+```
+
+## RTSP authentication test (Basic → Digest)
+
+Validate RTSP credentials by issuing a DESCRIBE request. Falls back from Basic to Digest auth automatically.
+
+```bash
+python -c "from config.custom_components.ezviz_cloud.pyezvizapi.test_cam_rtsp import TestRTSPAuth as T; T('<IP>', '<USER>', '<PASS>', '/Streaming/Channels/101').main()"
+```
+
+On success, the script prints a confirmation. On failure it raises one of:
+
+- `InvalidHost`: Hostname/IP or port issue
+- `AuthTestResultFailed`: Invalid credentials
+
+## Development
+
+Please format with Ruff and check typing with mypy.
+
+```bash
+ruff check .
+mypy config/custom_components/ezviz_cloud/pyezvizapi
+```
+
+Run style fixes where possible:
+
+```bash
+ruff check --fix config/custom_components/ezviz_cloud/pyezvizapi
+```
+
+Run tests with tox:
+
+```bash
+tox
+```
+
+## Side Notes
+
+There is no official API documentation. Much of this is based on reverse-engineering the Ezviz mobile app (Android/iOS). Some regions operate on separate endpoints; US example: `apiius.ezvizlife.com`.
+
+Example:
+
+```bash
+pyezvizapi -u username@domain.com -p PASS@123 -r apius.ezvizlife.com devices status
+```
+
+For advanced troubleshooting or new feature research, MITM proxy tools like mitmproxy/Charles/Fiddler can be used to inspect traffic from the app (see community guides for SSL unpinning and WSA usage).
+
+## Contributing
+
+Contributions are welcome — the API surface is large and there are many improvements possible.
+
+## Versioning
+
+We follow SemVer when publishing the library. See repository tags for released versions.
+
+## License
+
+Apache 2.0 — see `LICENSE.md`.
+
+---
+
+Draft versions: 0.0.x

pyezvizapi-1.0.4.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+pyezvizapi/__init__.py,sha256=-OxHqxA9h0JZQW__GoZd1aByGquIHawCnNdeNlIg2Qo,3382
+pyezvizapi/__main__.py,sha256=GmV-9mfXhbzZq3g--cpM6Tex8EX4DBHXE1jeDhD8UXs,24112
+pyezvizapi/api_endpoints.py,sha256=NSUKafpmd_DaNtmlOsRplXeQB1PYjZ4roClt_BNnNyE,5802
+pyezvizapi/camera.py,sha256=yHP4ENva6ep2BY85VvlyHvimCOCrHCwOCnCfpAC2mNY,28517
+pyezvizapi/cas.py,sha256=3zHe-_a0KchCmGeAj1of-pV6oMPRUmSCIiDqBFsTK8A,6025
+pyezvizapi/client.py,sha256=4c93Eg-0AQvxjxgBMX4dhi3ywOftxocr-4iIoM_HxRM,153968
+pyezvizapi/constants.py,sha256=Ae838wTtHpOyNBnLQf56CFGHXpG9kPmgotjP9--J5V4,13570
+pyezvizapi/exceptions.py,sha256=8rmxEUQdrziqMe-M1SeeRd0HtP2IDQ2xpJVj7wvOQyo,976
+pyezvizapi/feature.py,sha256=8QeAo6vnIev_ovlDnVvnRbC39Xe6piLgBlFEuFE7qIA,16789
+pyezvizapi/light_bulb.py,sha256=7kuOJmKsmAmE6KGJaUScjrRSTic8IhuToYrMRM-Y76s,7795
+pyezvizapi/models.py,sha256=NQzwTP0yEe2IWU-Vc6nAn87xulpTuo0MX2Rcf0WxifA,4176
+pyezvizapi/mqtt.py,sha256=uzEFT69LLCtP4paTSdCgMBkGAkuqRD02scfgqtK1bxU,22656
+pyezvizapi/test_cam_rtsp.py,sha256=pbuanoKs_Pryt2f5QctHIngzJG1nD6kv8nulQYh2yPc,5162
+pyezvizapi/test_mqtt.py,sha256=xUtyw5I3KBkMVGe2xhok7SWXFyZZMXrlMADoPo_5l_k,5744
+pyezvizapi/utils.py,sha256=B-Lt4p14TTcJyrZvJ699GiUGj6qcd4vGmkKUf13bf_I,15455
+pyezvizapi-1.0.4.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyezvizapi-1.0.4.3.dist-info/licenses/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyezvizapi-1.0.4.3.dist-info/METADATA,sha256=WWMQuriHh98Vj2f3uTsQhFdlC0PdHrp8l_zmP7eqcaQ,7586
+pyezvizapi-1.0.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyezvizapi-1.0.4.3.dist-info/top_level.txt,sha256=gMZTelIi8z7pXyTCQLLaIkxVRrDQ_lS2NEv0WgfHrHs,11
+pyezvizapi-1.0.4.3.dist-info/RECORD,,

pyezvizapi-1.0.2.3.dist-info/METADATA

@@ -1,27 +0,0 @@
-Metadata-Version: 2.4
-Name: pyezvizapi
-Version: 1.0.2.3
-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.11
-License-File: LICENSE
-License-File: LICENSE.md
-Requires-Dist: requests
-Requires-Dist: pandas
-Requires-Dist: paho-mqtt
-Requires-Dist: xmltodict
-Requires-Dist: pycryptodome
-Dynamic: author
-Dynamic: author-email
-Dynamic: description
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-Pilot your Ezviz cameras with this module. Please view readme on github