python-aidot-cameras 0.15.1__tar.gz → 0.15.2__tar.gz

{python_aidot_cameras-0.15.1/python_aidot_cameras.egg-info → python_aidot_cameras-0.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.1
+Version: 0.15.2
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.2}/aidot_cameras/camera/client.py

@@ -867,6 +867,8 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         self.latest_jpeg: Optional[bytes] = None
         self._streaming_active: bool = False
         self._stream_session: Optional[Any] = None
+        # Last resolution asked for, re-sent when a session starts.
+        self._desired_quality: Optional[str] = None
         self._stream_task: Optional["asyncio.Task[None]"] = None
         self._stream_mqtt_drain: Optional["asyncio.Future"] = None
         self._last_frame_time: float = 0.0
@@ -3354,6 +3356,8 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
 
             self._fast_attempt_override = None
             self._stream_session = session
+            # A remembered resolution is only deliverable once a session exists.
+            self._apply_pending_resolution()
             # Don't block solely on wait_done(): the SDES ffmpeg reads RTP over a
             # UDP socket with no input timeout, so when a battery camera tears the
             # session down (~49-72s) ffmpeg keeps waiting on dead sockets forever
@@ -3564,6 +3568,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 continue
 
             self._stream_session = session
+            self._apply_pending_resolution()
             try:
                 while self._streaming_active:
                     await asyncio.sleep(5.0)

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.2}/aidot_cameras/camera/controls.py

@@ -144,6 +144,13 @@ class _CameraControlsMixin:
         mirroring the official app's HD/SD toggle.  Rides the active stream
         session (SETSTREAMCTRL=800), so the camera must be streaming.
 
+        The choice is REMEMBERED and re-sent whenever a session next starts.
+        Without that it was simply dropped when nothing was streaming - and
+        since a camera is idle far more often than not, the usual outcome of
+        changing this was nothing at all, while the caller was told the setting
+        had been applied. Nothing else re-sent it, so "it will apply on the next
+        session" was not true of any code path.
+
         Source: f0.java g3() -> X2(800, SetStreamCtrlReq.parseContent(0, quality)).
         Payload <IB3x> = channel(0) + quality byte + 3 reserved.
         """
@@ -151,14 +158,37 @@ class _CameraControlsMixin:
         if q is None:
             _LOGGER.error("async_set_resolution: unknown quality %r", quality)
             return False
+        self._desired_quality = quality.lower()
         payload = struct.pack("<IB3x", 0, q)
         session = self._stream_session
         if session is None:
-            _LOGGER.warning("async_set_resolution: no active stream session")
-            return False
+            _LOGGER.info(
+                "resolution %s remembered; the camera is not streaming, so it "
+                "will be applied when a session next starts", quality)
+            return True
         ok = session._avio_cmd(SETSTREAMCTRL_CMD, payload)
         _LOGGER.debug(
             "set resolution %s (quality=%d) -> %s",
             quality, q, "sent" if ok else "no channel yet",
         )
         return ok
+
+    def _apply_pending_resolution(self) -> None:
+        """Re-send the remembered resolution now that a session exists.
+
+        Called when a stream session becomes active. Best-effort and silent on
+        failure: a stream that is up matters more than a quality preference, so
+        this must never be able to disturb it.
+        """
+        quality = getattr(self, "_desired_quality", None)
+        if not quality:
+            return
+        q = _STREAM_QUALITY.get(quality)
+        session = self._stream_session
+        if q is None or session is None:
+            return
+        try:
+            if session._avio_cmd(SETSTREAMCTRL_CMD, struct.pack("<IB3x", 0, q)):
+                _LOGGER.debug("re-applied remembered resolution %s", quality)
+        except Exception:
+            _LOGGER.debug("could not re-apply resolution %s", quality, exc_info=True)

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.15.1"
+version = "0.15.2"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.2/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.1
+Version: 0.15.2
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.15.1 → python_aidot_cameras-0.15.2}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -125,6 +125,7 @@ tests/test_persistent_mqtt.py
 tests/test_persistent_mqtt_robustness.py
 tests/test_playback_tls.py
 tests/test_post_merge_hardening.py
+tests/test_resolution_persists.py
 tests/test_restart_cycle.py
 tests/test_retry_policy.py
 tests/test_scripts_importable.py

python_aidot_cameras-0.15.2/tests/test_resolution_persists.py

@@ -0,0 +1,95 @@
+"""A resolution choice must survive being made while nothing is streaming.
+
+The setter rides the live session (SETSTREAMCTRL): with no session there is
+nothing to send it over. It used to return False and drop the choice entirely,
+and nothing re-sent it - so the usual outcome of changing resolution was
+nothing at all, because a camera is idle far more often than it is streaming.
+The caller was told the setting had been applied, and the comment in the
+integration's select claimed it would "take effect on the next session", which
+no code path did.
+"""
+
+import os
+import sys
+from unittest.mock import MagicMock
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import pytest
+
+from aidot_cameras.camera.constants import _STREAM_QUALITY, SETSTREAMCTRL_CMD
+from aidot_cameras.camera.controls import _CameraControlsMixin
+
+
+class _Cam(_CameraControlsMixin):
+    def __init__(self, session=None):
+        self._stream_session = session
+        self._desired_quality = None
+
+
+def _session():
+    s = MagicMock()
+    s._avio_cmd = MagicMock(return_value=True)
+    return s
+
+
+@pytest.mark.asyncio
+async def test_choice_made_while_idle_is_remembered_not_dropped():
+    cam = _Cam(session=None)
+
+    assert await cam.async_set_resolution("sd") is True
+    assert cam._desired_quality == "sd"
+
+
+@pytest.mark.asyncio
+async def test_remembered_choice_is_sent_when_a_session_starts():
+    cam = _Cam(session=None)
+    await cam.async_set_resolution("sd")
+
+    cam._stream_session = _session()
+    cam._apply_pending_resolution()
+
+    cam._stream_session._avio_cmd.assert_called_once()
+    cmd, payload = cam._stream_session._avio_cmd.call_args[0]
+    assert cmd == SETSTREAMCTRL_CMD
+    assert payload[4] == _STREAM_QUALITY["sd"]   # AVIOCTRL_QUALITY_MIDDLE
+
+
+@pytest.mark.asyncio
+async def test_hd_round_trips_too():
+    cam = _Cam(session=None)
+    await cam.async_set_resolution("hd")
+    cam._stream_session = _session()
+    cam._apply_pending_resolution()
+    assert cam._stream_session._avio_cmd.call_args[0][1][4] == _STREAM_QUALITY["hd"]
+
+
+@pytest.mark.asyncio
+async def test_a_live_session_still_gets_it_immediately():
+    """Unchanged behaviour when the camera is already streaming."""
+    cam = _Cam(session=_session())
+
+    assert await cam.async_set_resolution("sd") is True
+    cam._stream_session._avio_cmd.assert_called_once()
+
+
+def test_nothing_is_sent_when_no_choice_was_ever_made():
+    cam = _Cam(session=_session())
+    cam._apply_pending_resolution()
+    cam._stream_session._avio_cmd.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_an_unknown_quality_is_still_rejected():
+    cam = _Cam(session=_session())
+    assert await cam.async_set_resolution("ultra") is False
+    assert cam._desired_quality is None
+
+
+def test_reapply_never_disturbs_a_working_stream():
+    """A quality preference must never be able to break a stream that is up."""
+    cam = _Cam(session=_session())
+    cam._desired_quality = "sd"
+    cam._stream_session._avio_cmd.side_effect = RuntimeError("channel gone")
+
+    cam._apply_pending_resolution()          # must not raise