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

pyezvizapi/__init__.py

@@ -34,6 +34,34 @@ from .exceptions import (
     InvalidURL,
     PyEzvizError,
 )
+from .feature import (
+    day_night_mode_value,
+    day_night_sensitivity_value,
+    device_icr_dss_config,
+    display_mode_value,
+    get_algorithm_value,
+    has_algorithm_subtype,
+    has_osd_overlay,
+    iter_algorithm_entries,
+    iter_channel_algorithm_entries,
+    lens_defog_config,
+    lens_defog_value,
+    night_vision_config,
+    night_vision_duration_value,
+    night_vision_luminance_value,
+    night_vision_mode_value,
+    night_vision_payload,
+    normalize_port_security,
+    optionals_mapping,
+    port_security_config,
+    port_security_has_port,
+    port_security_port_enabled,
+    resolve_channel,
+    supplement_light_available,
+    supplement_light_enabled,
+    supplement_light_params,
+    support_ext_value,
+)
 from .light_bulb import EzvizLightBulb
 from .models import EzvizDeviceRecord, build_device_records_map
 from .mqtt import EzvizToken, MQTTClient, MqttData, ServiceUrls
@@ -71,4 +99,30 @@ __all__ = [
     "SupportExt",
     "TestRTSPAuth",
     "build_device_records_map",
+    "day_night_mode_value",
+    "day_night_sensitivity_value",
+    "device_icr_dss_config",
+    "display_mode_value",
+    "get_algorithm_value",
+    "has_algorithm_subtype",
+    "has_osd_overlay",
+    "iter_algorithm_entries",
+    "iter_channel_algorithm_entries",
+    "lens_defog_config",
+    "lens_defog_value",
+    "night_vision_config",
+    "night_vision_duration_value",
+    "night_vision_luminance_value",
+    "night_vision_mode_value",
+    "night_vision_payload",
+    "normalize_port_security",
+    "optionals_mapping",
+    "port_security_config",
+    "port_security_has_port",
+    "port_security_port_enabled",
+    "resolve_channel",
+    "supplement_light_available",
+    "supplement_light_enabled",
+    "supplement_light_params",
+    "support_ext_value",
 ]

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,12 +253,44 @@ 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"
     )
 
+    parser_unified = subparsers.add_parser(
+        "unifiedmsg",
+        help="Fetch unified message list (alarm feed) and dump URLs/metadata",
+    )
+    parser_unified.add_argument(
+        "--serials",
+        required=False,
+        help="Comma-separated serials to filter (default: all devices)",
+    )
+    parser_unified.add_argument(
+        "--limit",
+        type=int,
+        default=20,
+        help="Number of messages to request (max 50; default: 20)",
+    )
+    parser_unified.add_argument(
+        "--date",
+        required=False,
+        help="Date in YYYYMMDD format (default: today in API timezone)",
+    )
+    parser_unified.add_argument(
+        "--end-time",
+        required=False,
+        help="Pagination token (msgId) returned by previous call (default: latest)",
+    )
+    parser_unified.add_argument(
+        "--urls-only",
+        action="store_true",
+        help="Print only deviceSerial + media URLs instead of full metadata",
+    )
+
     return parser.parse_args(argv)
 
 
@@ -411,18 +452,86 @@ def _handle_devices_light(args: argparse.Namespace, client: EzvizClient) -> int:
 
 def _handle_pagelist(client: EzvizClient) -> int:
     """Output full pagelist (raw JSON) for exploration in editors like Notepad++."""
-    data = client._get_page_list()  # noqa: SLF001
+    data = client.get_page_list()
     _write_json(data)
     return 0
 
 
 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
 
 
+def _handle_unifiedmsg(args: argparse.Namespace, client: EzvizClient) -> int:
+    """Fetch unified message list and optionally dump media URLs."""
+
+    response = client.get_device_messages_list(
+        serials=args.serials,
+        limit=args.limit,
+        date=args.date,
+        end_time=args.end_time or "",
+    )
+    raw_messages = response.get("message")
+    if not isinstance(raw_messages, list):
+        raw_messages = response.get("messages")
+    if not isinstance(raw_messages, list):
+        raw_messages = []
+    messages: list[dict[str, Any]] = [msg for msg in raw_messages if isinstance(msg, dict)]
+
+    def _extract_url(message: dict[str, Any]) -> str | None:
+        url = message.get("pic")
+        if not url:
+            url = message.get("defaultPic") or message.get("image")
+        if not url:
+            ext = message.get("ext")
+            if isinstance(ext, dict):
+                pics = ext.get("pics")
+                if isinstance(pics, str) and pics:
+                    url = pics.split(";")[0]
+        return url
+
+    if args.urls_only:
+        for item in messages:
+            media_url = _extract_url(item)
+            if not media_url:
+                continue
+            sys.stdout.write(f"{item.get('deviceSerial', 'unknown')}: {media_url}\n")
+        return 0
+
+    if args.json:
+        _write_json(messages)
+        return 0
+
+    rows: list[dict[str, Any]] = []
+    for item in messages:
+        ext = item.get("ext")
+        ext_dict = ext if isinstance(ext, dict) else None
+        rows.append(
+            {
+                "deviceSerial": item.get("deviceSerial"),
+                "time": item.get("timeStr") or item.get("time"),
+                "subType": item.get("subType"),
+                "alarmType": ext_dict.get("alarmType") if ext_dict else None,
+                "title": item.get("title") or item.get("detail") or (ext_dict or {}).get("alarmName"),
+                "url": _extract_url(item) or "",
+                "msgId": item.get("msgId"),
+            }
+        )
+
+    if rows:
+        df = pd.DataFrame(rows)
+        _write_df(df)
+    else:
+        sys.stdout.write("No unified messages returned.\n")
+    return 0
+
+
 def _handle_light(args: argparse.Namespace, client: EzvizClient) -> int:
     """Handle `light` subcommands (toggle/status)."""
     light_bulb = EzvizLightBulb(client, args.serial)
@@ -535,7 +644,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
 
@@ -582,6 +694,8 @@ def main(argv: list[str] | None = None) -> int:
             return _handle_pagelist(client)
         if args.action == "device_infos":
             return _handle_device_infos(args, client)
+        if args.action == "unifiedmsg":
+            return _handle_unifiedmsg(args, client)
 
     except PyEzvizError as exp:
         _LOGGER.error("%s", exp)
@@ -594,7 +708,7 @@ def main(argv: list[str] | None = None) -> int:
         return 2
     finally:
         if args.save_token and args.token_file:
-            _save_token_file(args.token_file, cast(dict[str, Any], client._token))  # noqa: SLF001
+            _save_token_file(args.token_file, client.export_token())
         client.close_session()
 
 

pyezvizapi/api_endpoints.py

@@ -22,13 +22,22 @@ API_ENDPOINT_UNIFIEDMSG_LIST_GET = "/v3/unifiedmsg/list"
 API_ENDPOINT_IOT_FEATURE = "/v3/iot-feature/feature/"
 API_ENDPOINT_IOT_ACTION = "/v3/iot-feature/action/"
 API_ENDPOINT_CALLING_NOTIFY = "/v3/calling/"
+API_ENDPOINT_SPECIAL_BIZS_VOICES = "/v3/specialBizs/voices"
+API_ENDPOINT_SPECIAL_BIZS_A1S = "/v3/specialBizs/A1S/"
+API_ENDPOINT_SPECIAL_BIZS_V1_BATTERY = "/v3/specialBizs/v1/batteryDevices/"
 
 API_ENDPOINT_ALARMINFO_GET = "/v3/alarms/v2/advanced"
 API_ENDPOINT_V3_ALARMS = "/v3/alarms/"
 API_ENDPOINT_SET_LUMINANCE = "/v3/alarms/device/alarmLight/"
-API_ENDPOINT_REMOTE_UNLOCK = "/Video/1/DoorLockMgr/RemoteUnlockReq"
+API_ENDPOINT_ALARM_DEVICE_CHIME = "/v3/alarms/device/chime/"
+API_ENDPOINT_REMOTE_UNLOCK = "/DoorLockMgr/RemoteUnlockReq"
+API_ENDPOINT_REMOTE_LOCK = "/DoorLockMgr/RemoteLockReq"
+API_ENDPOINT_AUTOUPGRADE_SWITCH = "/v3/autoupgrade/v1/switch"
+API_ENDPOINT_UPGRADE_RULE = "/v3/upgraderule"
 
 API_ENDPOINT_DEVCONFIG_BY_KEY = "/v3/devconfig/v1/keyValue/"
+API_ENDPOINT_DEVCONFIG_OP = "/v3/devconfig/op"
+API_ENDPOINT_DEVCONFIG_MOTOR = "/v3/devconfig/motor"
 API_ENDPOINT_CAM_AUTH_CODE = "/v3/devconfig/authcode/query/"
 
 API_ENDPOINT_INTELLIGENT_APP = "/v3/intelligent-app/load/"
@@ -37,12 +46,27 @@ API_ENDPOINT_DEVICE_BASICS = "/v3/basics/v1/devices/"
 
 API_ENDPOINT_DETECTION_SENSIBILITY = "/api/device/configAlgorithm"
 API_ENDPOINT_DETECTION_SENSIBILITY_GET = "/api/device/queryAlgorithmConfig"
+API_ENDPOINT_SENSITIVITY = "/v3/devconfig/v1/sensitivity/"
 API_ENDPOINT_SET_DEFENCE_SCHEDULE = "/api/device/defence/plan2"
+API_ENDPOINT_DEVICE_SWITCH_STATUS_LEGACY = "/api/device/switchStatus"
 API_ENDPOINT_CAM_ENCRYPTKEY = "/api/device/query/encryptkey"
 API_ENDPOINT_OFFLINE_NOTIFY = "/api/device/notify/switch"
 API_ENDPOINT_CANCEL_ALARM = "/api/device/cancelAlarm"
 API_ENDPOINT_DEVICE_SYS_OPERATION = "/api/device/v2/sysOper/"
 API_ENDPOINT_DEVICE_STORAGE_STATUS = "/api/device/queryStorageStatus"
+API_ENDPOINT_DEVICE_UPDATE_NAME = "/api/device/updateName"
+API_ENDPOINT_DEVCONFIG_SECURITY_ACTIVATE = "/v3/devconfig/security/activate/"
+API_ENDPOINT_DEVCONFIG_SECURITY_CHALLENGE = "/v3/devconfig/security/challenge/"
+API_ENDPOINT_DEVICES_LOC = "/v3/devices/loc"
+API_ENDPOINT_IOT_VIRTUAL_BIND = "/v3/iot-virtual-device/bindDevice"
+API_ENDPOINT_DEVCONFIG_BASE = "/v3/devconfig"
+API_ENDPOINT_USERDEVICES_TOKEN = "/v3/userdevices/token"
+API_ENDPOINT_DEVICE_ACCESSORY_LINK = "/v3/devices/accessory/"
+API_ENDPOINT_DOORLOCK_USERS = "/v3/doorlocks/"
+API_ENDPOINT_IOT_FEATURE_PRODUCT_VOICE_CONFIG = "/v3/iot-feature/product/voice/config"
+API_ENDPOINT_USERS_LBS_SUB_DOMAIN = "/v3/users/lbs/sub/domain"
+API_ENDPOINT_SCD_APP_DEVICE_ADD = "/v3/scd/app/device/add"
+API_ENDPOINT_REMOTE_UNBIND_PROGRESS = "/v3/remote/unbind/device/applicant/"
 API_ENDPOINT_CREATE_PANORAMIC = "/api/panoramic/devices/pics/collect"
 API_ENDPOINT_RETURN_PANORAMIC = "/api/panoramic/devices/pics"
 
@@ -53,9 +77,37 @@ API_ENDPOINT_SWITCH_OTHER = "/switch"
 API_ENDPOINT_PTZCONTROL = "/ptzControl"
 API_ENDPOINT_ALARM_SOUND = "/alarm/sound"
 API_ENDPOINT_SWITCH_SOUND_ALARM = "/sendAlarm"
+API_ENDPOINT_ALARM_SET_CHANNEL_WHISTLE = "/alarm/setChannelWhistle"
+API_ENDPOINT_ALARM_SET_DEVICE_WHISTLE = "/alarm/setDeviceWhistle"
+API_ENDPOINT_ALARM_STOP_WHISTLE = "/alarm/stopWhistle"
+API_ENDPOINT_ALARM_GET_WHISTLE_STATUS_BY_CHANNEL = "/alarm/getWhistleStatusByChannel"
+API_ENDPOINT_ALARM_GET_WHISTLE_STATUS_BY_DEVICE = "/alarm/getWhistleStatusByDevice"
 API_ENDPOINT_DO_NOT_DISTURB = "/nodisturb"
 API_ENDPOINT_VIDEO_ENCRYPT = "encryptedInfo/risk"
 API_ENDPOINT_CHANGE_DEFENCE_STATUS = "/changeDefenceStatusReq"
+API_ENDPOINT_DEVICES_P2P_INFO = "/v3/devices/v2/p2p"
+API_ENDPOINT_USERDEVICES_P2P_INFO = "/v3/userdevices/v1/devices/p2p"
+API_ENDPOINT_USERDEVICES_KMS = "/v3/userdevices/v1/devices/kms"
+API_ENDPOINT_USERDEVICES_STATUS = "/v3/userdevices/v1/devices/status"
+API_ENDPOINT_USERDEVICES_V2 = "/v3/userdevices/v2/devices"
+API_ENDPOINT_USERDEVICES_SEARCH = "/v3/userdevices/v2/devices"
+API_ENDPOINT_STREAMING_RECORDS = "/v3/streaming/records"
+API_ENDPOINT_DEVICES_ENCRYPTKEY_BATCH = "/v3/devices/encryptkey/query/batch/risk"
+API_ENDPOINT_MANAGED_DEVICE_BASE = "/v3/userdevices/v1/managed/"
+API_ENDPOINT_SDCARD_BLACK_LEVEL = "/v3/devconfig/v1/sdcard/"
+API_ENDPOINT_TIME_PLAN_INFOS = "/v3/devconfig/v2/plan"
+API_ENDPOINT_FEEDBACK = "/v3/feedback/v2"
+API_ENDPOINT_SHARE_ACCEPT = "/v3/share/accept"
+API_ENDPOINT_SHARE_QUIT = "/v3/share/quit"
+API_ENDPOINT_DEVICE_EMAIL_ALERT = "/v3/unifiedmsg/notify/switch/128"
+API_ENDPOINT_DEVICES_AUTHENTICATE = "/v3/devices/authenticate/"
+API_ENDPOINT_DEVICES_SET_SWITCH_ENABLE = "/setSwitchEnableReq"
+API_ENDPOINT_SMARTHOME_OUTLET_LOG = (
+    "/v3/smarthome/outlet/log/switch/from/{from}/to/{to}"
+)
+API_ENDPOINT_DEVICES_ASSOCIATION_LINKED_IPC = (
+    "/v3/devices/association/linked/ipcList/byA1"
+)
 
 # MQTT
 API_ENDPOINT_REGISTER_MQTT = "/v1/getClientId"

pyezvizapi/camera.py

@@ -22,6 +22,11 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+DEFAULT_ALARM_IMAGE_URL = (
+    "https://eustatics.ezvizlife.com/ovs_mall/web/img/index/EZVIZ_logo.png?ver=3007907502"
+)
+UNIFIEDMSG_LOOKBACK_DAYS = 7
+
 
 class CameraStatus(TypedDict, total=False):
     """Typed mapping for Ezviz camera status payload."""
@@ -133,25 +138,54 @@ class EzvizCamera:
         """Fetch dictionary key."""
         return fetch_nested_value(self._device, keys, default_value)
 
-    def _alarm_list(self) -> None:
-        """Get last alarm info for this camera's self._serial.
+    def _alarm_list(self, prefetched: dict[str, Any] | None = None) -> None:
+        """Populate last alarm info for this camera.
+
+        Args:
+            prefetched: Optional unified message payload provided by the caller to
+                avoid an extra API request. When ``None``, the camera will query the
+                cloud API directly with a short date lookback window.
 
         Raises:
             InvalidURL: If the API endpoint/connection is invalid.
             HTTPError: If the API returns a non-success HTTP status.
             PyEzvizError: On Ezviz API contract errors or decoding failures.
         """
-        _alarmlist = self._client.get_alarminfo(self._serial)
-
-        total = fetch_nested_value(_alarmlist, ["page", "totalResults"], 0)
-        if total and total > 0:
-            self._last_alarm = _alarmlist.get("alarms", [{}])[0]
+        if prefetched:
+            self._last_alarm = self._normalize_unified_message(prefetched)
             _LOGGER.debug(
-                "Fetched last alarm for %s: %s", self._serial, self._last_alarm
+                "Using prefetched alarm for %s: %s", self._serial, self._last_alarm
             )
             self._motion_trigger()
-        else:
-            _LOGGER.debug("No alarms found for %s", self._serial)
+            return
+
+        response = self._client.get_device_messages_list(
+            serials=self._serial,
+            limit=1,
+            date="",
+            end_time="",
+        )
+        messages = response.get("message") or response.get("messages") or []
+        if not isinstance(messages, list):
+            messages = []
+        latest_message = next(
+            (
+                msg
+                for msg in messages
+                if isinstance(msg, dict)
+                and msg.get("deviceSerial") == self._serial
+            ),
+            None,
+        )
+        if latest_message is None:
+            _LOGGER.debug(
+                "No unified messages found for %s today",
+                self._serial,
+            )
+            return
+        self._last_alarm = self._normalize_unified_message(latest_message)
+        _LOGGER.debug("Fetched last alarm for %s: %s", self._serial, self._last_alarm)
+        self._motion_trigger()
 
     def _local_ip(self) -> str:
         """Fix empty ip value for certain cameras."""
@@ -170,6 +204,36 @@ class EzvizCamera:
 
         return "0.0.0.0"
 
+    def _resource_route(
+        self,
+    ) -> tuple[str, str, str | None, str | None]:
+        """Return resource id, local index, stream token, and optional type."""
+        resource_infos = self._device.get("resourceInfos") or []
+        info: dict[str, Any] | None = None
+        if isinstance(resource_infos, list):
+            info = next((item for item in resource_infos if isinstance(item, dict)), None)
+        elif isinstance(resource_infos, dict):
+            info = next(
+                (item for item in resource_infos.values() if isinstance(item, dict)), None
+            )
+
+        resource_id = "Video"
+        local_index: str = "1"
+        stream_token: str | None = None
+        lock_type: str | None = None
+
+        if info:
+            if isinstance(info.get("resourceId"), str):
+                resource_id = info["resourceId"]
+            local_idx_value = info.get("localIndex")
+            if isinstance(local_idx_value, (int, str)):
+                local_index = str(local_idx_value)
+            stream_token = info.get("streamToken")
+            if isinstance(info.get("type"), str):
+                lock_type = info["type"]
+
+        return resource_id, local_index, stream_token, lock_type
+
     def _motion_trigger(self) -> None:
         """Create motion sensor based on last alarm time.
 
@@ -186,6 +250,68 @@ class EzvizCamera:
             "last_alarm_time_str": last_alarm_str,
         }
 
+    def _normalize_unified_message(self, message: dict[str, Any]) -> dict[str, Any]:
+        """Normalize unified message payload to legacy alarm shape."""
+        ext = message.get("ext")
+        if not isinstance(ext, dict):
+            ext = {}
+
+        pics_field = ext.get("pics")
+        multi_pic = None
+        if isinstance(pics_field, str) and pics_field:
+            multi_pic = next(
+                (part for part in pics_field.split(";") if part), None
+            )
+
+        def _first_valid(*candidates: Any) -> str:
+            for candidate in candidates:
+                if isinstance(candidate, str) and candidate:
+                    return candidate
+            return DEFAULT_ALARM_IMAGE_URL
+
+        pic_url = _first_valid(
+            message.get("pic"),
+            multi_pic,
+            message.get("defaultPic"),
+        )
+
+        alarm_name = (
+            message.get("title")
+            or message.get("detail")
+            or message.get("sampleName")
+            or "NoAlarm"
+        )
+        alarm_type = ext.get("alarmType") or message.get("subType") or "0000"
+
+        time_value: Any = message.get("time")
+        if isinstance(time_value, str):
+            try:
+                time_value = int(time_value)
+            except (TypeError, ValueError):
+                try:
+                    time_value = float(time_value)
+                except (TypeError, ValueError):
+                    time_value = None
+
+        time_str = message.get("timeStr") or ext.get("alarmStartTime")
+
+        return {
+            "alarmId": message.get("msgId"),
+            "deviceSerial": message.get("deviceSerial"),
+            "channel": message.get("channel"),
+            "alarmStartTime": time_value,
+            "alarmStartTimeStr": time_str,
+            "alarmTime": time_value,
+            "alarmTimeStr": time_str,
+            "picUrl": pic_url,
+            "picChecksum": message.get("picChecksum") or ext.get("picChecksum"),
+            "picCrypt": message.get("picCrypt") or ext.get("picCrypt"),
+            "sampleName": alarm_name,
+            "alarmType": alarm_type,
+            "msgSource": "unifiedmsg",
+            "ext": ext,
+        }
+
     def _get_tzinfo(self) -> datetime.tzinfo:
         """Return tzinfo from camera setting if recognizable, else local tzinfo."""
         tz_val = self.fetch_key(["STATUS", "optionals", "timeZone"])
@@ -204,10 +330,17 @@ class EzvizCamera:
         )
         return bool(sched and sched.get("enable"))
 
-    def status(self, refresh: bool = True) -> CameraStatus:
+    def status(
+        self,
+        refresh: bool = True,
+        *,
+        latest_alarm: dict[str, Any] | None = None,
+    ) -> CameraStatus:
         """Return the status of the camera.
 
         refresh: if True, updates alarm info via network before composing status.
+        latest_alarm: Optional prefetched unified message payload to avoid an extra
+            HTTP request when ``refresh`` is True.
 
         Raises:
             InvalidURL: If the API endpoint/connection is invalid while refreshing.
@@ -215,7 +348,7 @@ class EzvizCamera:
             PyEzvizError: On Ezviz API contract errors or decoding failures.
         """
         if refresh:
-            self._alarm_list()
+            self._alarm_list(prefetched=latest_alarm)
 
         name = (
             self._record.name
@@ -301,7 +434,7 @@ class EzvizCamera:
             or self._last_alarm.get("alarmStartTimeStr"),
             "last_alarm_pic": self._last_alarm.get(
                 "picUrl",
-                "https://eustatics.ezvizlife.com/ovs_mall/web/img/index/EZVIZ_logo.png?ver=3007907502",
+                DEFAULT_ALARM_IMAGE_URL,
             ),
             "last_alarm_type_code": self._last_alarm.get("alarmType", "0000"),
             "last_alarm_type_name": self._last_alarm.get("sampleName", "NoAlarm"),
@@ -397,7 +530,16 @@ class EzvizCamera:
         """
         _LOGGER.debug("Remote door unlock for %s", self._serial)
         user = str(getattr(self._client, "_token", {}).get("username", ""))
-        return self._client.remote_unlock(self._serial, user, 2)
+        resource_id, local_index, stream_token, lock_type = self._resource_route()
+        return self._client.remote_unlock(
+            self._serial,
+            user,
+            2,
+            resource_id=resource_id,
+            local_index=local_index,
+            stream_token=stream_token,
+            lock_type=lock_type,
+        )
 
     def gate_unlock(self) -> bool:
         """Unlock the gate lock.
@@ -409,7 +551,46 @@ class EzvizCamera:
         """
         _LOGGER.debug("Remote gate unlock for %s", self._serial)
         user = str(getattr(self._client, "_token", {}).get("username", ""))
-        return self._client.remote_unlock(self._serial, user, 1)
+        resource_id, local_index, stream_token, lock_type = self._resource_route()
+        return self._client.remote_unlock(
+            self._serial,
+            user,
+            1,
+            resource_id=resource_id,
+            local_index=local_index,
+            stream_token=stream_token,
+            lock_type=lock_type,
+        )
+
+    def door_lock(self) -> bool:
+        """Lock the door remotely."""
+        _LOGGER.debug("Remote door lock for %s", self._serial)
+        user = str(getattr(self._client, "_token", {}).get("username", ""))
+        resource_id, local_index, stream_token, lock_type = self._resource_route()
+        return self._client.remote_lock(
+            self._serial,
+            user,
+            2,
+            resource_id=resource_id,
+            local_index=local_index,
+            stream_token=stream_token,
+            lock_type=lock_type,
+        )
+
+    def gate_lock(self) -> bool:
+        """Lock the gate remotely."""
+        _LOGGER.debug("Remote gate lock for %s", self._serial)
+        user = str(getattr(self._client, "_token", {}).get("username", ""))
+        resource_id, local_index, stream_token, lock_type = self._resource_route()
+        return self._client.remote_lock(
+            self._serial,
+            user,
+            1,
+            resource_id=resource_id,
+            local_index=local_index,
+            stream_token=stream_token,
+            lock_type=lock_type,
+        )
 
     def alarm_notify(self, enable: bool) -> bool:
         """Enable/Disable camera notification when movement is detected.

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"