pyezvizapi 1.0.2.2__py3-none-any.whl → 1.0.2.4__py3-none-any.whl

pyezvizapi/__main__.py

@@ -26,7 +26,9 @@ _LOGGER = logging.getLogger(__name__)
 def _setup_logging(debug: bool) -> None:
     """Configure root logger for CLI usage."""
     level = logging.DEBUG if debug else logging.INFO
-    logging.basicConfig(level=level, stream=sys.stderr, format="%(levelname)s: %(message)s")
+    logging.basicConfig(
+        level=level, stream=sys.stderr, format="%(levelname)s: %(message)s"
+    )
     if debug:
         # Verbose requests logging in debug mode
         requests_log = logging.getLogger("requests.packages.urllib3")
@@ -94,7 +96,7 @@ def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         type=str,
         default="status",
         help="Light bulbs action to perform",
-        choices=["status"]
+        choices=["status"],
     )
     parser_device_lights.add_argument(
         "--refresh",
@@ -125,7 +127,9 @@ def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
 
     subparsers_camera = parser_camera.add_subparsers(dest="camera_action")
 
-    parser_camera_status = subparsers_camera.add_parser("status", help="Get the status of the camera")
+    parser_camera_status = subparsers_camera.add_parser(
+        "status", help="Get the status of the camera"
+    )
     parser_camera_status.add_argument(
         "--refresh",
         action=argparse.BooleanOptionalAction,
@@ -229,14 +233,19 @@ def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     )
 
     parser_camera_select = subparsers_camera.add_parser(
-        "select", help="Change the value of a multi-value option (for on/off value, see 'switch' command)"
+        "select",
+        help="Change the value of a multi-value option (for on/off value, see 'switch' command)",
     )
 
     parser_camera_select.add_argument(
         "--battery_work_mode",
         required=False,
         help="Change the work mode for battery powered camera",
-        choices=[mode.name for mode in BatteryCameraWorkMode if mode is not BatteryCameraWorkMode.UNKNOWN],
+        choices=[
+            mode.name
+            for mode in BatteryCameraWorkMode
+            if mode is not BatteryCameraWorkMode.UNKNOWN
+        ],
     )
 
     # Dump full pagelist for exploration
@@ -244,7 +253,8 @@ def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
 
     # Dump device infos mapping (optionally for a single serial)
     parser_device_infos = subparsers.add_parser(
-        "device_infos", help="Output device infos (raw JSON), optionally filtered by serial"
+        "device_infos",
+        help="Output device infos (raw JSON), optionally filtered by serial",
     )
     parser_device_infos.add_argument(
         "--serial", required=False, help="Optional serial to filter a single device"
@@ -418,7 +428,11 @@ def _handle_pagelist(client: EzvizClient) -> int:
 
 def _handle_device_infos(args: argparse.Namespace, client: EzvizClient) -> int:
     """Output device infos mapping (raw JSON), optionally filtered by serial."""
-    data = client.get_device_infos(args.serial) if args.serial else client.get_device_infos()
+    data = (
+        client.get_device_infos(args.serial)
+        if args.serial
+        else client.get_device_infos()
+    )
     _write_json(data)
     return 0
 
@@ -535,7 +549,10 @@ def _load_token_file(path: str | None) -> dict[str, Any] | None:
         return None
     try:
         return cast(dict[str, Any], json.loads(p.read_text(encoding="utf-8")))
-    except (OSError, json.JSONDecodeError):  # pragma: no cover - tolerate malformed file
+    except (
+        OSError,
+        json.JSONDecodeError,
+    ):  # pragma: no cover - tolerate malformed file
         _LOGGER.warning("Failed to read token file: %s", p)
         return None
 

pyezvizapi/camera.py

@@ -4,14 +4,17 @@ from __future__ import annotations
 
 import datetime
 import logging
-import re
 from typing import TYPE_CHECKING, Any, Literal, TypedDict, cast
-from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 from .constants import BatteryCameraWorkMode, DeviceSwitchType, SoundMode
 from .exceptions import PyEzvizError
 from .models import EzvizDeviceRecord
-from .utils import fetch_nested_value, string_to_list
+from .utils import (
+    compute_motion_from_alarm,
+    fetch_nested_value,
+    parse_timezone_value,
+    string_to_list,
+)
 
 if TYPE_CHECKING:
     from .client import EzvizClient
@@ -172,110 +175,10 @@ class EzvizCamera:
 
         Prefer numeric epoch fields if available to avoid parsing localized strings.
         """
-        # Use timezone-aware datetimes. Compute both camera-local and UTC "now".
         tzinfo = self._get_tzinfo()
-        now_local = datetime.datetime.now(tz=tzinfo).replace(microsecond=0)
-        now_utc = datetime.datetime.now(tz=datetime.UTC).replace(microsecond=0)
-
-        # Prefer epoch fields if available
-        epoch = self._last_alarm.get("alarmStartTime") or self._last_alarm.get(
-            "alarmTime"
-        )
-        last_alarm_dt: datetime.datetime | None = None
-        # Capture string time if present so we can cross-check epoch skew
-        raw_time_str = str(
-            self._last_alarm.get("alarmStartTimeStr")
-            or self._last_alarm.get("alarmTimeStr")
-            or ""
+        active, seconds_out, last_alarm_str = compute_motion_from_alarm(
+            self._last_alarm, tzinfo
         )
-        if epoch is not None:
-            try:
-                # Accept int/float/str; auto-detect ms vs s
-                if isinstance(epoch, str):
-                    epoch = float(epoch)
-                ts = float(epoch)
-                if ts > 1e11:  # very likely milliseconds
-                    ts = ts / 1000.0
-                # Convert epoch to UTC for robust delta; derive display time in camera tz
-                event_utc = datetime.datetime.fromtimestamp(ts, tz=datetime.UTC)
-                last_alarm_dt = event_utc.astimezone(tzinfo)
-                # Some devices appear to report epoch as local time rather than UTC.
-                # If the provided string timestamp exists and differs significantly
-                # from the epoch-based time, reinterpret the epoch as local time.
-                if raw_time_str:
-                    raw_norm = raw_time_str
-                    if "Today" in raw_norm:
-                        raw_norm = raw_norm.replace("Today", str(now_local.date()))
-                    try:
-                        dt_str_local = datetime.datetime.strptime(
-                            raw_norm, "%Y-%m-%d %H:%M:%S"
-                        ).replace(tzinfo=tzinfo)
-                        diff = abs(
-                            (
-                                event_utc
-                                - dt_str_local.astimezone(datetime.UTC)
-                            ).total_seconds()
-                        )
-                        if diff > 120:
-                            # Reinterpret the epoch as local clock time in camera tz
-                            naive_utc = datetime.datetime.fromtimestamp(ts, tz=datetime.UTC).replace(tzinfo=None)
-                            event_local_reint = naive_utc.replace(tzinfo=tzinfo)
-                            event_utc = event_local_reint.astimezone(datetime.UTC)
-                            last_alarm_dt = event_local_reint
-                    except ValueError:
-                        pass
-            except (
-                TypeError,
-                ValueError,
-                OSError,
-            ):  # fall back to string parsing below
-                last_alarm_dt = None
-
-        last_alarm_str: str | None = None
-        if last_alarm_dt is None:
-            # Fall back to string parsing
-            raw = raw_time_str
-            if not raw:
-                return
-            if "Today" in raw:
-                raw = raw.replace("Today", str(now_local.date()))
-            try:
-                last_alarm_dt = datetime.datetime.strptime(
-                    raw, "%Y-%m-%d %H:%M:%S"
-                ).replace(tzinfo=tzinfo)
-                last_alarm_str = last_alarm_dt.strftime("%Y-%m-%d %H:%M:%S")
-            except ValueError:  # Unrecognized format; give up gracefully
-                _LOGGER.debug(
-                    "Unrecognized alarm time format for %s: %s", self._serial, raw
-                )
-                self._alarmmotiontrigger = {
-                    "alarm_trigger_active": False,
-                    "timepassed": None,
-                    "last_alarm_time_str": raw or None,
-                }
-                return
-        else:
-            # We selected epoch path; format a human-readable local string
-            last_alarm_str = last_alarm_dt.astimezone(tzinfo).strftime(
-                "%Y-%m-%d %H:%M:%S"
-            )
-
-        # Compute elapsed seconds since the last alarm. If the timestamp is
-        # somehow in the future (timezone mismatch or clock skew), do not
-        # report a motion trigger; clamp the exposed seconds to 0.0.
-        # Use UTC delta when epoch was provided; otherwise compute in camera tz.
-        if epoch is not None and last_alarm_dt is not None:
-            event_utc_for_delta = last_alarm_dt.astimezone(datetime.UTC)
-            delta = now_utc - event_utc_for_delta
-        else:
-            delta = now_local - last_alarm_dt
-        seconds = float(delta.total_seconds())
-        if seconds < 0:
-            active = False
-            seconds_out = 0.0
-        else:
-            active = seconds < 60.0
-            seconds_out = seconds
 
         self._alarmmotiontrigger = {
             "alarm_trigger_active": active,
@@ -284,41 +187,9 @@ class EzvizCamera:
         }
 
     def _get_tzinfo(self) -> datetime.tzinfo:
-        """Return tzinfo from camera setting if recognizable, else local tzinfo.
-
-        Attempts to parse common formats like 'UTC+02:00', 'GMT+8', '+0530', or IANA names.
-        Falls back to local timezone.
-        """
+        """Return tzinfo from camera setting if recognizable, else local tzinfo."""
         tz_val = self.fetch_key(["STATUS", "optionals", "timeZone"])
-        # IANA zone name
-        if isinstance(tz_val, str) and "/" in tz_val:
-            try:
-                return ZoneInfo(tz_val)
-            except ZoneInfoNotFoundError:
-                pass
-        # Offset formats
-        offset_minutes: int | None = None
-        if isinstance(tz_val, int):
-            # Heuristic: treat small absolute values as hours, large as minutes/seconds
-            if -14 <= tz_val <= 14:
-                offset_minutes = tz_val * 60
-            elif -24 * 60 <= tz_val <= 24 * 60:
-                offset_minutes = tz_val
-            elif -24 * 3600 <= tz_val <= 24 * 3600:
-                offset_minutes = int(tz_val / 60)
-        elif isinstance(tz_val, str):
-            s = tz_val.strip().upper().replace("UTC", "").replace("GMT", "")
-            # Normalize formats like '+02:00', '+0200', '+2'
-            m = re.match(r"^([+-]?)(\d{1,2})(?::?(\d{2}))?$", s)
-            if m:
-                sign = -1 if m.group(1) == "-" else 1
-                hours = int(m.group(2))
-                minutes = int(m.group(3)) if m.group(3) else 0
-                offset_minutes = sign * (hours * 60 + minutes)
-        if offset_minutes is not None:
-            return datetime.timezone(datetime.timedelta(minutes=offset_minutes))
-        # Fallback to local timezone
-        return datetime.datetime.now().astimezone().tzinfo or datetime.UTC
+        return parse_timezone_value(tz_val)
 
     def _is_alarm_schedules_enabled(self) -> bool:
         """Check if alarm schedules enabled."""

pyezvizapi/cas.py

@@ -38,7 +38,9 @@ class EzvizCAS:
             "api_url": "apiieu.ezvizlife.com",
         }
         if not token or "service_urls" not in token:
-            raise PyEzvizError("Missing service_urls in token; call EzvizClient.login() first")
+            raise PyEzvizError(
+                "Missing service_urls in token; call EzvizClient.login() first"
+            )
         self._service_urls: dict[str, Any] = token["service_urls"]
 
     def cas_get_encryption(self, devserial: str) -> dict[str, Any]:
@@ -53,7 +55,7 @@ class EzvizCAS:
             f"\x01"  # Check or order?
             f"\x00\x00\x00\x00\x00\x00\x02\t\x00\x00\x00\x00"
             f'<?xml version="1.0" encoding="utf-8"?>\n<Request>\n\t'
-            f'<ClientID>{self._token["session_id"]}</ClientID>'
+            f"<ClientID>{self._token['session_id']}</ClientID>"
             f"\n\t<Sign>{FEATURE_CODE}</Sign>\n\t"
             f"<DevSerial>{devserial}</DevSerial>"
             f"\n\t<ClientType>0</ClientType>\n</Request>\n"

pyezvizapi/client.py

@@ -167,7 +167,7 @@ class EzvizClient:
         DeviceCatagories.BASE_STATION_DEVICE_CATEGORY.value,
         DeviceCatagories.CAT_EYE_CATEGORY.value,
         DeviceCatagories.LIGHTING.value,
-        DeviceCatagories.W2H_BASE_STATION_DEVICE_CATEGORY.value, # @emeric699 Adding support for W2H Base Station
+        DeviceCatagories.W2H_BASE_STATION_DEVICE_CATEGORY.value,
     ]
 
     def __init__(
@@ -189,7 +189,8 @@ class EzvizClient:
             self._session.headers["sessionId"] = str(token["session_id"])  # ensure str
         self._token: ClientToken = cast(
             ClientToken,
-            token or {
+            token
+            or {
                 "session_id": None,
                 "rf_session_id": None,
                 "username": None,
@@ -262,7 +263,7 @@ class EzvizClient:
         if json_result["meta"]["code"] == 1100:
             self._token["api_url"] = json_result["loginArea"]["apiDomain"]
             _LOGGER.warning(
-                "region_incorrect: serial=%s code=%s msg=%s",
+                "Region_incorrect: serial=%s code=%s msg=%s",
                 "unknown",
                 1100,
                 self._token["api_url"],
@@ -319,7 +320,11 @@ class EzvizClient:
             )
             req.raise_for_status()
         except requests.HTTPError as err:
-            if retry_401 and err.response is not None and err.response.status_code == 401:
+            if (
+                retry_401
+                and err.response is not None
+                and err.response.status_code == 401
+            ):
                 if max_retries >= MAX_RETRIES:
                     raise HTTPError from err
                 # Re-login and retry once
@@ -344,7 +349,10 @@ class EzvizClient:
             return cast(dict, resp.json())
         except ValueError as err:
             raise PyEzvizError(
-                "Impossible to decode response: " + str(err) + "\nResponse was: " + str(resp.text)
+                "Impossible to decode response: "
+                + str(err)
+                + "\nResponse was: "
+                + str(resp.text)
             ) from err
 
     @staticmethod
@@ -413,11 +421,17 @@ class EzvizClient:
             req = self._session.send(request=prepared, timeout=self._timeout)
             req.raise_for_status()
         except requests.HTTPError as err:
-            if retry_401 and err.response is not None and err.response.status_code == 401:
+            if (
+                retry_401
+                and err.response is not None
+                and err.response.status_code == 401
+            ):
                 if max_retries >= MAX_RETRIES:
                     raise HTTPError from err
                 self.login()
-                return self._send_prepared(prepared, retry_401=retry_401, max_retries=max_retries + 1)
+                return self._send_prepared(
+                    prepared, retry_401=retry_401, max_retries=max_retries + 1
+                )
             raise HTTPError from err
         return req
 
@@ -478,7 +492,7 @@ class EzvizClient:
                 # Prefer modern meta.code; fall back to legacy resultCode
                 code = self._response_code(payload)
                 _LOGGER.warning(
-                    "http_retry: serial=%s code=%s msg=%s",
+                    "Http_retry: serial=%s code=%s msg=%s",
                     serial or "unknown",
                     code,
                     log,
@@ -549,7 +563,7 @@ class EzvizClient:
             # session is wrong, need to relogin and retry
             self.login()
             _LOGGER.warning(
-                "http_retry: serial=%s code=%s msg=%s",
+                "Http_retry: serial=%s code=%s msg=%s",
                 "unknown",
                 self._meta_code(json_output),
                 "pagelist_relogin",
@@ -673,7 +687,11 @@ class EzvizClient:
         json_output = self._request_json(
             "PUT",
             f"{API_ENDPOINT_DEVICES}{serial}{API_ENDPOINT_SWITCH_OTHER}",
-            params={"channelNo": channel_number, "enable": enable, "switchType": status_type},
+            params={
+                "channelNo": channel_number,
+                "enable": enable,
+                "switchType": status_type,
+            },
             retry_401=True,
             max_retries=max_retries,
         )
@@ -704,7 +722,9 @@ class EzvizClient:
             serial=serial,
         )
         if self._meta_code(json_output) != 200:
-            raise PyEzvizError(f"Could not arm or disarm Camera {serial}: Got {json_output})")
+            raise PyEzvizError(
+                f"Could not arm or disarm Camera {serial}: Got {json_output})"
+            )
         return True
 
     def set_battery_camera_work_mode(self, serial: str, value: int) -> bool:
@@ -1017,9 +1037,14 @@ class EzvizClient:
                         self._light_bulbs[device] = EzvizLightBulb(
                             self, device, dict(rec.raw)
                         ).status()
-                    except (PyEzvizError, KeyError, TypeError, ValueError) as err:  # pragma: no cover - defensive
+                    except (
+                        PyEzvizError,
+                        KeyError,
+                        TypeError,
+                        ValueError,
+                    ) as err:  # pragma: no cover - defensive
                         _LOGGER.warning(
-                            "load_device_failed: serial=%s code=%s msg=%s",
+                            "Load_device_failed: serial=%s code=%s msg=%s",
                             device,
                             "load_error",
                             str(err),
@@ -1029,9 +1054,14 @@ class EzvizClient:
                         # Create camera object
                         cam = EzvizCamera(self, device, dict(rec.raw))
                         self._cameras[device] = cam.status(refresh=refresh)
-                    except (PyEzvizError, KeyError, TypeError, ValueError) as err:  # pragma: no cover - defensive
+                    except (
+                        PyEzvizError,
+                        KeyError,
+                        TypeError,
+                        ValueError,
+                    ) as err:  # pragma: no cover - defensive
                         _LOGGER.warning(
-                            "load_device_failed: serial=%s code=%s msg=%s",
+                            "Load_device_failed: serial=%s code=%s msg=%s",
                             device,
                             "load_error",
                             str(err),
@@ -1100,7 +1130,9 @@ class EzvizClient:
             try:
                 support_ext = result[_serial].get("deviceInfos", {}).get("supportExt")
                 if isinstance(support_ext, str) and support_ext:
-                    result[_serial]["deviceInfos"]["supportExt"] = json.loads(support_ext)
+                    result[_serial]["deviceInfos"]["supportExt"] = json.loads(
+                        support_ext
+                    )
             except (TypeError, ValueError):
                 # Leave as-is if not valid JSON
                 pass
@@ -1199,14 +1231,16 @@ class EzvizClient:
 
             code = str(json_output.get("resultCode"))
             if code == "20002":
-                raise EzvizAuthVerificationCode(f"MFA code required: Got {json_output})")
+                raise EzvizAuthVerificationCode(
+                    f"MFA code required: Got {json_output})"
+                )
             if code == "2009":
                 raise DeviceException(f"Device not reachable: Got {json_output})")
             if code == "0":
                 return json_output.get("encryptkey")
             if code == "-1" and attempt < attempts:
                 _LOGGER.warning(
-                    "http_retry: serial=%s code=%s msg=%s",
+                    "Http_retry: serial=%s code=%s msg=%s",
                     serial,
                     code,
                     "cam_key_not_found",
@@ -1357,7 +1391,9 @@ class EzvizClient:
             raise PyEzvizError(
                 f"Could not send command to create panoramic photo: Got {json_output})"
             )
-        raise PyEzvizError("Could not send command to create panoramic photo: exceeded retries")
+        raise PyEzvizError(
+            "Could not send command to create panoramic photo: exceeded retries"
+        )
 
     def return_panoramic(self, serial: str, max_retries: int = 0) -> Any:
         """Return panoramic image url list."""
@@ -1526,7 +1562,7 @@ class EzvizClient:
         except requests.HTTPError as err:
             if err.response.status_code == 401:
                 _LOGGER.warning(
-                    "http_warning: serial=%s code=%s msg=%s",
+                    "Http_warning: serial=%s code=%s msg=%s",
                     "unknown",
                     401,
                     "logout_already_invalid",
@@ -1678,7 +1714,9 @@ class EzvizClient:
         else:
             raise PyEzvizError(f"Invalid action '{action}'. Use 'add' or 'remove'.")
 
-        json_output = self._request_json(method, url_path, retry_401=True, max_retries=max_retries)
+        json_output = self._request_json(
+            method, url_path, retry_401=True, max_retries=max_retries
+        )
         self._ensure_ok(json_output, f"Could not {action} intelligent app")
 
         return True

pyezvizapi/constants.py

@@ -464,4 +464,4 @@ class DeviceCatagories(Enum):
     BASE_STATION_DEVICE_CATEGORY = "XVR"
     CAT_EYE_CATEGORY = "CatEye"
     LIGHTING = "lighting"
-    W2H_BASE_STATION_DEVICE_CATEGORY = "IGateWay" # @emeric699 Adding support for W2H Base Station
+    W2H_BASE_STATION_DEVICE_CATEGORY = "IGateWay"

pyezvizapi/test_cam_rtsp.py

@@ -22,6 +22,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 +38,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 +55,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 +67,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 +81,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,15 +93,23 @@ 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)
+        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"])
@@ -115,9 +133,13 @@ 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)
+            describe = genmsg_describe(
+                url, seq, self._rtsp_details["defaultUserAgent"], auth_seq
+            )
             print(describe)
             session.send(describe.encode())
             msg1 = session.recv(self._rtsp_details["bufLen"])
@@ -132,4 +154,6 @@ class TestRTSPAuth:
                 raise AuthTestResultFailed("Credentials not valid!!")
 
         print("Basic Auth test passed. Credentials Valid!")
+
+
 # ruff: noqa: T201

pyezvizapi/utils.py

@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+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
 
@@ -188,3 +191,158 @@ def generate_unique_code() -> str:
     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]:
+    """Normalize EZVIZ alarm timestamps.
+
+    Returns a tuple of:
+      - alarm_dt_local: datetime in the camera's timezone (for display)
+      - alarm_dt_utc: datetime in UTC (for robust delta calculation)
+      - alarm_time_str: formatted 'YYYY-MM-DD HH:MM:SS' string in camera tz
+
+    Behavior:
+      - Prefer epoch fields (alarmStartTime/alarmTime). Interpret as UTC by default.
+      - If a string time exists and differs from the epoch by >120 seconds,
+        reinterpret the epoch as if reported in camera local time.
+      - If no epoch, fall back to parsing the string time in the camera tz.
+    """
+    # Prefer epoch
+    epoch = last_alarm.get("alarmStartTime") or last_alarm.get("alarmTime")
+    raw_time_str = str(
+        last_alarm.get("alarmStartTimeStr") or last_alarm.get("alarmTimeStr") or ""
+    )
+
+    alarm_dt_local: datetime.datetime | None = None
+    alarm_dt_utc: datetime.datetime | None = None
+    alarm_str: str | None = None
+
+    now_local = datetime.datetime.now(tz=tzinfo)
+
+    if epoch is not None:
+        try:
+            ts = float(epoch if not isinstance(epoch, str) else float(epoch))
+            if ts > 1e11:  # milliseconds
+                ts /= 1000.0
+            event_utc = datetime.datetime.fromtimestamp(ts, tz=datetime.UTC)
+            alarm_dt_local = event_utc.astimezone(tzinfo)
+            alarm_dt_utc = event_utc
+
+            if raw_time_str:
+                raw_norm = raw_time_str.replace("Today", str(now_local.date()))
+                try:
+                    dt_str_local = datetime.datetime.strptime(
+                        raw_norm, "%Y-%m-%d %H:%M:%S"
+                    ).replace(tzinfo=tzinfo)
+                    diff = abs(
+                        (
+                            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)
+                        event_local_reint = naive_utc.replace(tzinfo=tzinfo)
+                        alarm_dt_local = event_local_reint
+                        alarm_dt_utc = event_local_reint.astimezone(datetime.UTC)
+                except ValueError:
+                    pass
+
+            if alarm_dt_local is not None:
+                alarm_str = alarm_dt_local.strftime("%Y-%m-%d %H:%M:%S")
+                return alarm_dt_local, alarm_dt_utc, alarm_str
+            # If conversion failed unexpectedly, fall through to string parsing
+        except (TypeError, ValueError, OSError):
+            alarm_dt_local = None
+
+    # Fallback to string parsing
+    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_utc = alarm_dt_local.astimezone(datetime.UTC)
+            alarm_str = alarm_dt_local.strftime("%Y-%m-%d %H:%M:%S")
+        except ValueError:
+            pass
+
+    return alarm_dt_local, alarm_dt_utc, alarm_str
+
+
+def compute_motion_from_alarm(
+    last_alarm: dict[str, Any], tzinfo: datetime.tzinfo, window_seconds: float = 60.0
+) -> tuple[bool, float, str | None]:
+    """Compute motion state and seconds-since from an alarm payload.
+
+    Returns (active, seconds_since, last_alarm_time_str).
+    - Uses UTC for delta when epoch-derived UTC is available.
+    - Falls back to camera local tz deltas when only string times are present.
+    - Clamps negative deltas to 0.0 and deactivates motion.
+    """
+    alarm_dt_local, alarm_dt_utc, alarm_str = normalize_alarm_time(last_alarm, tzinfo)
+    if alarm_dt_local is None:
+        return False, 0.0, None
+
+    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
+
+    seconds = float(delta.total_seconds())
+    if seconds < 0:
+        return False, 0.0, alarm_str
+
+    return seconds < window_seconds, seconds, alarm_str
+
+
+def parse_timezone_value(tz_val: Any) -> datetime.tzinfo:
+    """Parse EZVIZ timeZone value into a tzinfo.
+
+    Supports:
+      - IANA names like 'Europe/Paris'
+      - Offsets like 'UTC+02:00', 'GMT-5', '+0530', or integers (hours/minutes/seconds)
+    Falls back to the local system timezone, or UTC if unavailable.
+    """
+    # IANA zone name
+    if isinstance(tz_val, str) and "/" in tz_val:
+        try:
+            return ZoneInfo(tz_val)
+        except ZoneInfoNotFoundError:
+            pass
+
+    # Numeric offsets
+    offset_minutes: int | None = None
+    if isinstance(tz_val, int):
+        if -14 <= tz_val <= 14:
+            offset_minutes = tz_val * 60
+        elif -24 * 60 <= tz_val <= 24 * 60:
+            offset_minutes = tz_val
+        elif -24 * 3600 <= tz_val <= 24 * 3600:
+            offset_minutes = int(tz_val / 60)
+    elif isinstance(tz_val, str):
+        s = tz_val.strip().upper().replace("UTC", "").replace("GMT", "")
+        m = _re.match(r"^([+-]?)(\d{1,2})(?::?(\d{2}))?$", s)
+        if m:
+            sign = -1 if m.group(1) == "-" else 1
+            hours = int(m.group(2))
+            minutes = int(m.group(3)) if m.group(3) else 0
+            offset_minutes = sign * (hours * 60 + minutes)
+
+    if offset_minutes is not None:
+        return datetime.timezone(datetime.timedelta(minutes=offset_minutes))
+
+    # Fallbacks
+    return datetime.datetime.now().astimezone().tzinfo or datetime.UTC

{pyezvizapi-1.0.2.2.dist-info → pyezvizapi-1.0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyezvizapi
-Version: 1.0.2.2
+Version: 1.0.2.4
 Summary: Pilot your Ezviz cameras
 Home-page: https://github.com/RenierM26/pyEzvizApi/
 Author: Renier Moorcroft

pyezvizapi-1.0.2.4.dist-info/RECORD

@@ -0,0 +1,21 @@
+pyezvizapi/__init__.py,sha256=IDnIN_nfIISVwuy0cVBh4wspgAav6MuOJCQGajjyU3g,1881
+pyezvizapi/__main__.py,sha256=9uttTuOfO22tzyomJIV8ebFJ-G-YUNDYOadZ_0AgdNA,20925
+pyezvizapi/api_endpoints.py,sha256=rk6VinLVCn-B6DxnhfV79liplNpgUsipNbTEa_MRVwU,2755
+pyezvizapi/camera.py,sha256=Pl5oIEdrFcv1Hz5sQI1IyyJIDCMjOjQdtExgKzmLoK8,22102
+pyezvizapi/cas.py,sha256=3zHe-_a0KchCmGeAj1of-pV6oMPRUmSCIiDqBFsTK8A,6025
+pyezvizapi/client.py,sha256=I20oMXw8sVVmuvgVj7eC1J6KFK_ziLM0OsJRpMuR6xs,72418
+pyezvizapi/constants.py,sha256=RPyKUj0OX2VypIzcGcmmnLPDvDlCMUaZGpwADB53q4U,12585
+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=aOL-gexZgYvCCaNQ03M4vZan91d5p2Fl_qsFykn9NW4,22365
+pyezvizapi/test_cam_rtsp.py,sha256=O9NHh-vcNFfnzNw8jbuhM9a_5TWfNZIMXaJP7Lmkaj4,5162
+pyezvizapi/test_mqtt.py,sha256=Orn-fwZPJIE4G5KROMX0MRAkLwU6nLb9LUtXyb2ZCQs,4147
+pyezvizapi/utils.py,sha256=G8gGjG0ecdN05Y0vxOHvcQMtQXgVB7nHzyvCzz66kLk,12148
+pyezvizapi-1.0.2.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyezvizapi-1.0.2.4.dist-info/licenses/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyezvizapi-1.0.2.4.dist-info/METADATA,sha256=DnOoi3MRCjee1zRpnunI115JXlwTp3Of9Z2fBN_f1Z4,695
+pyezvizapi-1.0.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyezvizapi-1.0.2.4.dist-info/entry_points.txt,sha256=_BSJ3eNb2H_AZkRdsv1s4mojqWn3N7m503ujvg1SudA,56
+pyezvizapi-1.0.2.4.dist-info/top_level.txt,sha256=gMZTelIi8z7pXyTCQLLaIkxVRrDQ_lS2NEv0WgfHrHs,11
+pyezvizapi-1.0.2.4.dist-info/RECORD,,

pyezvizapi-1.0.2.2.dist-info/RECORD

@@ -1,21 +0,0 @@
-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=8F8oyLnvZgl67Id6_R1m3OuhnDPNV92mTKGyLAKIFy8,28250
-pyezvizapi/cas.py,sha256=ISmb-eTPuacI10L87lULbQ-oDMBuygO7Tf-s9f-tvYE,5995
-pyezvizapi/client.py,sha256=Bp5eQbn4-pjsZicfpWy6jD5bDjQeYFw-SN1p0uzKJRY,71782
-pyezvizapi/constants.py,sha256=SqdJRQSRdVYQxMgJa__AgorzdWglgA4MM4H2fq3QLAE,12633
-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=aOL-gexZgYvCCaNQ03M4vZan91d5p2Fl_qsFykn9NW4,22365
-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.2.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyezvizapi-1.0.2.2.dist-info/licenses/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyezvizapi-1.0.2.2.dist-info/METADATA,sha256=aY8Dh0Ia8j4gTVBxgJW_JnoGFDumEfAfQTDMvNqZI2U,695
-pyezvizapi-1.0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyezvizapi-1.0.2.2.dist-info/entry_points.txt,sha256=_BSJ3eNb2H_AZkRdsv1s4mojqWn3N7m503ujvg1SudA,56
-pyezvizapi-1.0.2.2.dist-info/top_level.txt,sha256=gMZTelIi8z7pXyTCQLLaIkxVRrDQ_lS2NEv0WgfHrHs,11
-pyezvizapi-1.0.2.2.dist-info/RECORD,,