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

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/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,156 @@ 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.3.dist-info}/METADATA

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

{pyezvizapi-1.0.2.2.dist-info → pyezvizapi-1.0.2.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 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/camera.py,sha256=Pl5oIEdrFcv1Hz5sQI1IyyJIDCMjOjQdtExgKzmLoK8,22102
 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
@@ -11,11 +11,11 @@ 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,,
+pyezvizapi/utils.py,sha256=bOWLIytbELQfwBpA2LnhP1m8OthmOk9Vhh_uUXTFpoc,12124
+pyezvizapi-1.0.2.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyezvizapi-1.0.2.3.dist-info/licenses/LICENSE.md,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyezvizapi-1.0.2.3.dist-info/METADATA,sha256=xvvts4etMltvpLLaIr0lcKhm1quwBYCJbFqltigk55U,695
+pyezvizapi-1.0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyezvizapi-1.0.2.3.dist-info/entry_points.txt,sha256=_BSJ3eNb2H_AZkRdsv1s4mojqWn3N7m503ujvg1SudA,56
+pyezvizapi-1.0.2.3.dist-info/top_level.txt,sha256=gMZTelIi8z7pXyTCQLLaIkxVRrDQ_lS2NEv0WgfHrHs,11
+pyezvizapi-1.0.2.3.dist-info/RECORD,,