zm-py 0.5.5.dev11__tar.gz → 0.5.5.dev13__tar.gz

{zm_py-0.5.5.dev11 → zm_py-0.5.5.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zm-py
-Version: 0.5.5.dev11
+Version: 0.5.5.dev13
 Summary: A loose python wrapper around the ZoneMinder REST API.
 License: Apache-2.0
 License-File: LICENSE.md

{zm_py-0.5.5.dev11 → zm_py-0.5.5.dev13}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zm-py"
-version = "0.5.5.dev11"
+version = "0.5.5.dev13"
 description = "A loose python wrapper around the ZoneMinder REST API."
 authors = ["Rohan Kapoor <rohan@rohankapoor.com>"]
 maintainers = ["Nic Boet <nic@boet.cc>"]

{zm_py-0.5.5.dev11 → zm_py-0.5.5.dev13}/tests/test_monitor.py

@@ -221,6 +221,53 @@ class TestMonitorImageUrls:
         assert "user=" not in mon.mjpeg_image_url
 
 
+# ---------------------------------------------------------------------------
+# Stream scale & maxfps URL params
+# ---------------------------------------------------------------------------
+
+
+class TestMonitorStreamScaleMaxfps:
+    def test_scale_in_mjpeg_url(self):
+        """scale=50 should appear in MJPEG URL."""
+        mon = Monitor(StubClient(), _make_raw(), scale=50)
+        assert "scale=50" in mon.mjpeg_image_url
+
+    def test_scale_in_still_url(self):
+        """scale=50 should appear in still URL."""
+        mon = Monitor(StubClient(), _make_raw(), scale=50)
+        assert "scale=50" in mon.still_image_url
+
+    def test_maxfps_in_mjpeg_url(self):
+        """maxfps=5.0 should appear in MJPEG URL (mode=jpeg)."""
+        mon = Monitor(StubClient(), _make_raw(), maxfps=5.0)
+        assert "maxfps=5.0" in mon.mjpeg_image_url
+
+    def test_maxfps_not_in_still_url(self):
+        """maxfps should NOT appear in still URL (mode=single)."""
+        mon = Monitor(StubClient(), _make_raw(), maxfps=5.0)
+        assert "maxfps" not in mon.still_image_url
+
+    def test_both_scale_and_maxfps_in_mjpeg(self):
+        """Both params in MJPEG URL when both set."""
+        mon = Monitor(StubClient(), _make_raw(), scale=75, maxfps=10.0)
+        assert "scale=75" in mon.mjpeg_image_url
+        assert "maxfps=10.0" in mon.mjpeg_image_url
+
+    def test_no_scale_maxfps_when_none(self):
+        """Neither param should appear when both are None (backwards compat)."""
+        mon = Monitor(StubClient(), _make_raw())
+        assert "scale=" not in mon.mjpeg_image_url
+        assert "maxfps=" not in mon.mjpeg_image_url
+        assert "scale=" not in mon.still_image_url
+        assert "maxfps=" not in mon.still_image_url
+
+    def test_only_scale_still_url(self):
+        """Still URL should have scale but not maxfps when both set."""
+        mon = Monitor(StubClient(), _make_raw(), scale=25, maxfps=3.0)
+        assert "scale=25" in mon.still_image_url
+        assert "maxfps" not in mon.still_image_url
+
+
 # ---------------------------------------------------------------------------
 # is_recording
 # ---------------------------------------------------------------------------
@@ -297,6 +344,83 @@ class TestMonitorIsRecording:
         mon = Monitor(client, _make_raw())
         assert mon.is_recording is True
 
+    def test_uses_alarm_command_helper(self):
+        """is_recording should use _alarm_command('status') internally."""
+        client = StubClient(get_state_return={"status": 2})
+        mon = Monitor(client, _make_raw())
+        assert mon.is_recording is True
+        # Verify get_state was called with the correct alarm status URL
+        assert client._get_state_call_count == 1
+
+
+# ---------------------------------------------------------------------------
+# set_force_alarm_state
+# ---------------------------------------------------------------------------
+
+class TestForceAlarmState:
+    """Test force alarm on/off via the alarm command API."""
+
+    def test_force_alarm_on(self):
+        """set_force_alarm_state(True) should call command:on."""
+        calls = []
+        client = StubClient(get_state_return={"status": "1"})
+        original_get_state = client.get_state
+
+        def tracking_get_state(api_url):
+            calls.append(api_url)
+            return original_get_state(api_url)
+
+        client.get_state = tracking_get_state
+        mon = Monitor(client, _make_raw())
+        mon.set_force_alarm_state(True)
+        assert any("command:on" in c for c in calls)
+
+    def test_force_alarm_off(self):
+        """set_force_alarm_state(False) should call command:off."""
+        calls = []
+        client = StubClient(get_state_return={"status": "1"})
+        original_get_state = client.get_state
+
+        def tracking_get_state(api_url):
+            calls.append(api_url)
+            return original_get_state(api_url)
+
+        client.get_state = tracking_get_state
+        mon = Monitor(client, _make_raw())
+        mon.set_force_alarm_state(False)
+        assert any("command:off" in c for c in calls)
+
+    def test_force_alarm_on_url_contains_monitor_id(self):
+        """The alarm URL should contain the correct monitor ID."""
+        calls = []
+        client = StubClient(get_state_return={"status": "1"})
+        original_get_state = client.get_state
+
+        def tracking_get_state(api_url):
+            calls.append(api_url)
+            return original_get_state(api_url)
+
+        client.get_state = tracking_get_state
+        mon = Monitor(client, _make_raw(mid=42))
+        mon.set_force_alarm_state(True)
+        assert any("id:42" in c for c in calls)
+
+    def test_force_alarm_logs_on_failure(self, caplog):
+        """Warning should be logged when API returns falsy response."""
+        client = StubClient(get_state_return={})
+        mon = Monitor(client, _make_raw())
+        with caplog.at_level("WARNING"):
+            mon.set_force_alarm_state(True)
+        assert "Failed to set force alarm" in caplog.text
+
+    def test_force_alarm_no_warning_on_success(self, caplog):
+        """No warning when API returns a truthy response."""
+        client = StubClient(get_state_return={"status": "1"})
+        mon = Monitor(client, _make_raw())
+        with caplog.at_level("WARNING"):
+            mon.set_force_alarm_state(True)
+        assert "Failed to set force alarm" not in caplog.text
+
 
 # ---------------------------------------------------------------------------
 # is_available

{zm_py-0.5.5.dev11 → zm_py-0.5.5.dev13}/zoneminder/monitor.py

@@ -195,10 +195,12 @@ class TimePeriod(Enum):
 class Monitor:
     """Represents a Monitor from ZoneMinder."""
 
-    def __init__(self, client, raw_result):
+    def __init__(self, client, raw_result, *, scale=None, maxfps=None):
         """Create a new Monitor."""
         self._client = client
         self._raw_result = raw_result
+        self._scale: int | None = scale
+        self._maxfps: float | None = maxfps
         self._last_update = time.monotonic()
         raw_monitor = raw_result["Monitor"]
         self._monitor_id = int(raw_monitor["Id"])
@@ -349,12 +351,23 @@ class Monitor:
         """Get the still jpeg image url of this Monitor."""
         return self._still_image_url
 
+    def _alarm_command(self, command: str):
+        """Send an alarm command for this monitor.
+
+        Valid commands: 'status', 'on', 'off', 'cancel'.
+        Returns the raw API response dict (empty dict on failure).
+        """
+        return (
+            self._client.get_state(
+                f"api/monitors/alarm/id:{self._monitor_id}/command:{command}.json"
+            )
+            or {}
+        )
+
     @property
     def is_recording(self) -> bool | None:
         """Indicate if this Monitor is currently recording."""
-        status_response = self._client.get_state(
-            f"api/monitors/alarm/id:{self._monitor_id}/command:status.json"
-        )
+        status_response = self._alarm_command("status")
 
         if not status_response:
             _LOGGER.warning("Could not get status for monitor %s.", self._monitor_id)
@@ -369,6 +382,22 @@ class Monitor:
         except (ValueError, TypeError):
             return False
 
+    def set_force_alarm_state(self, state: bool) -> None:
+        """Force a monitor into or out of alarm state.
+
+        When forced on, ZoneMinder will begin recording on this monitor
+        regardless of motion detection.  When forced off, the forced alarm
+        is cancelled and the monitor returns to its normal detection mode.
+        """
+        command = "on" if state else "off"
+        response = self._alarm_command(command)
+        if not response:
+            _LOGGER.warning(
+                "Failed to set force alarm %s for monitor %s",
+                command,
+                self._monitor_id,
+            )
+
     @property
     def is_available(self) -> bool:
         """Indicate if this Monitor is currently available."""
@@ -404,13 +433,16 @@ class Monitor:
 
     def _build_image_url(self, monitor, mode) -> str:
         """Build and return a ZoneMinder camera image url."""
-        query = urlencode(
-            {
-                "mode": mode,
-                "buffer": monitor["StreamReplayBuffer"],
-                "monitor": monitor["Id"],
-            }
-        )
+        params: dict[str, str | int | float] = {
+            "mode": mode,
+            "buffer": monitor["StreamReplayBuffer"],
+            "monitor": monitor["Id"],
+        }
+        if self._scale is not None:
+            params["scale"] = self._scale
+        if self._maxfps is not None and mode == "jpeg":
+            params["maxfps"] = self._maxfps
+        query = urlencode(params)
         zms_url = self._client.get_zms_url_for_monitor(monitor)
         url = f"{zms_url}?{query}"
         _LOGGER.debug("Monitor %s %s URL (without auth): %s", monitor["Id"], mode, url)

{zm_py-0.5.5.dev11 → zm_py-0.5.5.dev13}/zoneminder/zm.py

@@ -33,6 +33,8 @@ class ZoneMinder:
         server_path=DEFAULT_SERVER_PATH,
         zms_path=DEFAULT_ZMS_PATH,
         verify_ssl=True,
+        stream_scale=None,
+        stream_maxfps=None,
     ) -> None:
         """Create a ZoneMinder API Client."""
         self._server_url = ZoneMinder._build_server_url(server_host, server_path)
@@ -40,6 +42,8 @@ class ZoneMinder:
         self._username = username
         self._password = password
         self._verify_ssl = verify_ssl
+        self._stream_scale: int | None = stream_scale
+        self._stream_maxfps: float | None = stream_maxfps
         self._session = requests.Session()
         self._session.verify = verify_ssl
         self._auth_token: str | None = None
@@ -51,6 +55,11 @@ class ZoneMinder:
     def login(self) -> bool:
         """Login to the ZoneMinder API."""
         _LOGGER.debug("Attempting to login to ZoneMinder")
+        # Clear any stale token before re-auth.  If JWT auth fails and we
+        # fall back to legacy session cookies, a leftover token would be
+        # sent as ?token=… on every subsequent request, causing ZM to reject
+        # the stale JWT with 401 even though the session cookie is valid.
+        self._auth_token = None
 
         login_post = {}
         if self._username:
@@ -152,7 +161,14 @@ class ZoneMinder:
                 if req.ok:
                     break
                 if attempt < ZoneMinder.LOGIN_RETRIES - 1:
-                    self.login()
+                    _LOGGER.debug(
+                        "API call %s %s returned HTTP %s, re-authenticating",
+                        method.upper(),
+                        api_url,
+                        req.status_code,
+                    )
+                    login_ok = self.login()
+                    _LOGGER.debug("Re-login succeeded: %s", login_ok)
 
             else:
                 _LOGGER.error(
@@ -208,7 +224,14 @@ class ZoneMinder:
         monitors = []
         for raw_result in raw_monitors["monitors"]:
             _LOGGER.debug("Initializing camera %s", raw_result["Monitor"]["Id"])
-            monitors.append(Monitor(self, raw_result))
+            monitors.append(
+                Monitor(
+                    self,
+                    raw_result,
+                    scale=self._stream_scale,
+                    maxfps=self._stream_maxfps,
+                )
+            )
 
         return monitors