python-aidot-cameras 1.0.0b28__tar.gz → 1.0.0b30__tar.gz

{python_aidot_cameras-1.0.0b28/python_aidot_cameras.egg-info → python_aidot_cameras-1.0.0b30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0b28
+Version: 1.0.0b30
 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-1.0.0b28 → python_aidot_cameras-1.0.0b30}/aidot_cameras/__main__.py

@@ -77,6 +77,7 @@ import aiohttp
 
 from .client import AidotClient
 from .cloud_auth import (  # noqa: F401  (re-exported for callers and tests)
+    CloudAuthUnavailable,
     _install_token_cache,
     _make_client,
     _read_token_file,
@@ -86,8 +87,6 @@ from .const import CONF_DEVICE_LIST, CONF_ID, CONF_MODEL_ID, CONF_NAME
 
 _LOGGER = logging.getLogger("aidot.go2rtc")
 
-DEFAULT_COUNTRY = os.environ.get("AIDOT_COUNTRY", "US")
-
 
 def _env_bool(name: str) -> bool | None:
     """Tri-state env flag: '1' -> True, '0' -> False, unset -> None (library default)."""
@@ -131,7 +130,11 @@ def _go2rtc_source(dev_id: str, is_sdes: bool) -> str:
 async def cmd_list() -> int:
     """Print device id + transport for every camera, plus paste-ready go2rtc YAML."""
     async with aiohttp.ClientSession() as session:
-        client = await _make_client(session)
+        # CloudAuthUnavailable is the library-side signal; a CLI exits on it.
+        try:
+            client = await _make_client(session)
+        except CloudAuthUnavailable as exc:
+            sys.exit(str(exc))
         cams = await _cameras(client)
         if not cams:
             print("No IPC cameras found on this account.")
@@ -158,7 +161,10 @@ async def cmd_list() -> int:
 async def cmd_stream(dev_id: str, output_url: str) -> int:
     """Open one camera's keepalive and push/serve it to ``output_url``."""
     async with aiohttp.ClientSession() as session:
-        client = await _make_client(session)
+        try:
+            client = await _make_client(session)
+        except CloudAuthUnavailable as exc:
+            sys.exit(str(exc))
         cams = await _cameras(client)
         device = next((d for d in cams if d[CONF_ID] == dev_id), None)
         if device is None:

{python_aidot_cameras-1.0.0b28 → python_aidot_cameras-1.0.0b30}/aidot_cameras/camera/protocol.py

@@ -2950,6 +2950,12 @@ def decode_remb_bitrate(pkt: bytes) -> int:
     return mantissa << exp
 
 
+#: RTPFB feedback message types (RFC 4585 s6.1, RFC 5104 s4.2).
+_RTPFB_PT = 205
+_FMT_NACK = 1
+_FMT_TMMBR = 3
+
+
 def build_nack(sender_ssrc: int, media_ssrc: int, lost_seqs: "list") -> bytes:
     """An RTCP Generic NACK (RFC 4585 s6.2.1) asking for ``lost_seqs`` again.
 
@@ -2985,7 +2991,7 @@ def build_nack(sender_ssrc: int, media_ssrc: int, lost_seqs: "list") -> bytes:
             i += 1
         fci.append(struct.pack("!HH", pid, blp))
 
-    pkt = (struct.pack("!BBH", 0x80 | 1, 205, 0)
+    pkt = (struct.pack("!BBH", 0x80 | _FMT_NACK, _RTPFB_PT, 0)
            + struct.pack("!II", sender_ssrc & 0xFFFFFFFF,
                          media_ssrc & 0xFFFFFFFF)
            + b"".join(fci))
@@ -2993,12 +2999,6 @@ def build_nack(sender_ssrc: int, media_ssrc: int, lost_seqs: "list") -> bytes:
     return pkt[:2] + struct.pack("!H", len(pkt) // 4 - 1) + pkt[4:]
 
 
-#: RTPFB feedback message types (RFC 4585 s6.1, RFC 5104 s4.2).
-_RTPFB_PT = 205
-_FMT_NACK = 1
-_FMT_TMMBR = 3
-
-
 def build_tmmbr(sender_ssrc: int, media_ssrc: int, bitrate_bps: int,
                 overhead: int = 60) -> bytes:
     """A TMMBR (RFC 5104 s4.2.1) telling ``media_ssrc`` not to exceed a rate.

{python_aidot_cameras-1.0.0b28 → python_aidot_cameras-1.0.0b30}/aidot_cameras/camera/sdes_open.py

@@ -241,19 +241,28 @@ def _widen_media_rcvbuf(sock, kind: str, device_id: str = "?") -> int:
     return got
 
 
-def _sdes_offer_bandwidth_kbps():
-    """A receive-bandwidth ceiling for the offer, in kbps, or None for none.
-
-    Off unless ``AIDOT_SDES_OFFER_BANDWIDTH_KBPS`` names a positive integer.
-    An unparseable value is off rather than an error: this is read while an
-    offer is being built, and a typo must not take a camera off the air.
+def _env_positive(name: str, cast=int, off=None):
+    """Parse ``name`` as a positive number; anything else means ``off``.
+
+    One body for the experiment knobs below - the third copy of this parser
+    was the rule-of-three moment.  ``off`` is the knob's disabled value (None
+    for the ints, 0.0 for the delay), and unparseable input is disabled rather
+    than an error: these are read while sessions are being built, and a typo
+    must not take a camera off the air.
     """
-    raw = os.environ.get("AIDOT_SDES_OFFER_BANDWIDTH_KBPS")
+    raw = os.environ.get(name)
+    if raw is None:
+        return off
     try:
-        kbps = int(str(raw).strip())
-    except (TypeError, ValueError, AttributeError):
-        return None
-    return kbps if kbps > 0 else None
+        value = cast(raw.strip())
+    except ValueError:
+        return off
+    return value if value > 0 else off
+
+
+def _sdes_offer_bandwidth_kbps():
+    """A receive-bandwidth ceiling for the offer, in kbps, or None for none."""
+    return _env_positive("AIDOT_SDES_OFFER_BANDWIDTH_KBPS")
 
 
 def _offer_bandwidth_line(kbps) -> str:
@@ -381,13 +390,8 @@ def _send_video_nack(send, srtcp_sess, sender_ssrc: int,
     """
     if not lost_seqs:
         return False
-    try:
-        raw = build_nack(sender_ssrc, media_ssrc, lost_seqs)
-        send(srtcp_sess.protect_rtcp(raw) if srtcp_sess is not None else raw)
-        return True
-    except Exception:
-        _LOGGER.debug("NACK send failed", exc_info=True)
-        return False
+    return _send_rtcp_fb(
+        send, srtcp_sess, build_nack(sender_ssrc, media_ssrc, lost_seqs))
 
 
 def _sdes_tmmbr_bps():
@@ -396,11 +400,7 @@ def _sdes_tmmbr_bps():
     Off unless ``AIDOT_SDES_TMMBR_BPS`` names a positive integer.  Unparseable
     is off rather than an error: this is read while a session is running.
     """
-    try:
-        bps = int(str(os.environ.get("AIDOT_SDES_TMMBR_BPS")).strip())
-    except (TypeError, ValueError, AttributeError):
-        return None
-    return bps if bps > 0 else None
+    return _env_positive("AIDOT_SDES_TMMBR_BPS")
 
 
 def _sdes_tmmbr_after_s() -> float:
@@ -413,11 +413,7 @@ def _sdes_tmmbr_after_s() -> float:
     working SD control.  Both windows of one session share the codec and the
     scene, so neither can confound it.
     """
-    try:
-        after = float(str(os.environ.get("AIDOT_SDES_TMMBR_AFTER_S")).strip())
-    except (TypeError, ValueError, AttributeError):
-        return 0.0
-    return after if after > 0 else 0.0
+    return _env_positive("AIDOT_SDES_TMMBR_AFTER_S", cast=float, off=0.0)
 
 
 def _tmmbr_ready(first_video_ts, now: float, after_s: float) -> bool:
@@ -431,6 +427,38 @@ def _tmmbr_ready(first_video_ts, now: float, after_s: float) -> bool:
     return (now - first_video_ts) >= after_s
 
 
+def _send_rtcp_fb(send, srtcp_sess, raw: bytes) -> bool:
+    """Protect-and-send tail shared by the NACK, TMMBR and REMB helpers.
+
+    One body for the ``protect_rtcp``-if-session-else-raw dance and the
+    swallow-and-debug-log error policy.  It was written three times before
+    this, and the copy that drifted (REMB's, still inline in the loop body)
+    is the one where the raw-socket relay bug hid.  Never raises: these run
+    inside the bridge's packet loop.
+    """
+    try:
+        send(srtcp_sess.protect_rtcp(raw) if srtcp_sess is not None else raw)
+        return True
+    except Exception:
+        _LOGGER.debug("RTCP feedback send failed", exc_info=True)
+        return False
+
+
+def _send_video_remb(send, srtcp_sess, sender_ssrc: int,
+                     media_ssrc: int, target_bps) -> bool:
+    """Put one REMB on the camera's RTCP path.  True if it went out.
+
+    Same shape and same relay-aware ``send`` contract as
+    :func:`_send_video_nack` - the REMB logic previously lived inline in the
+    loop body, and being the only feedback path without a helper is exactly
+    how it kept the raw-socket write long after the NACK path was fixed.
+    """
+    if not target_bps or target_bps <= 0:
+        return False
+    return _send_rtcp_fb(
+        send, srtcp_sess, build_remb(sender_ssrc, [media_ssrc], target_bps))
+
+
 def _send_video_tmmbr(send, srtcp_sess, sender_ssrc: int,
                       media_ssrc: int, bitrate_bps) -> bool:
     """Put one TMMBR on the camera's RTCP path.  True if it went out.
@@ -446,13 +474,8 @@ def _send_video_tmmbr(send, srtcp_sess, sender_ssrc: int,
     """
     if not bitrate_bps or bitrate_bps <= 0:
         return False
-    try:
-        raw = build_tmmbr(sender_ssrc, media_ssrc, bitrate_bps)
-        send(srtcp_sess.protect_rtcp(raw) if srtcp_sess is not None else raw)
-        return True
-    except Exception:
-        _LOGGER.debug("TMMBR send failed", exc_info=True)
-        return False
+    return _send_rtcp_fb(
+        send, srtcp_sess, build_tmmbr(sender_ssrc, media_ssrc, bitrate_bps))
 
 
 #: Sender SSRC on every RTCP we send the camera.  Load-bearing, not cosmetic:
@@ -2008,6 +2031,11 @@ class _SdesOpenMixin:
         # this replaced; AIDOT_SDES_VIDEO_PT_ORDER reorders it without ever
         # narrowing it.
         _video_pt_order = _resolve_sdes_video_pt_order()
+        # Read ONCE and feed both the SDP line and the status receipt below:
+        # two independent env reads let the receipt name a value that never
+        # reached the wire, which is the false-receipt trap the receipt
+        # exists to close.
+        _bw_kbps = _sdes_offer_bandwidth_kbps()
         _video_pt_list, _video_codec_attrs = _sdes_offer_video_codec_lines(
             _video_pt_order)
         sdes_offer_sdp = (
@@ -2050,7 +2078,7 @@ class _SdesOpenMixin:
             # video m-section
             + f"m=video {_offer_video_port} RTP/SAVPF {_video_pt_list}\r\n"
             f"c=IN IP4 {_offer_video_ip}\r\n"
-            + _offer_bandwidth_line(_sdes_offer_bandwidth_kbps())
+            + _offer_bandwidth_line(_bw_kbps)
             + "a=recvonly\r\n"
             "a=mid:1\r\n"
             f"a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:{srtp_key_video}\r\n"
@@ -2103,7 +2131,6 @@ class _SdesOpenMixin:
         # is not evidence the line reached the wire.  Measured 2026-08-23: a
         # b=AS arm scored identically to its control and the only available
         # check for the knob was reading the env back out of the harness.
-        _bw_kbps = _sdes_offer_bandwidth_kbps()
         if _bw_kbps and _status:
             _status(f"SDES: offer receive-bandwidth ceiling b=AS:{_bw_kbps}")
 
@@ -4199,33 +4226,29 @@ class _SdesOpenMixin:
                     # skipping a tick until the sender exists costs a second,
                     # falling back costs correctness on the very sessions this
                     # is for.
-                    _remb_send = getattr(_bridge_fn, '_send_to_cam', None)
+                    # Guard order is cost order: the module constant first,
+                    # so the default REMB-off config pays nothing per packet
+                    # (the sender lookup used to sit above this line and ran
+                    # ~300x/s for a feature that ships disabled).
                     if (REMB_TARGET_BPS > 0
                             and hasattr(_bridge_fn, '_cam_video_ssrc')
-                            and _remb_send is not None
+                            and (_remb_send := getattr(
+                                _bridge_fn, '_send_to_cam', None)) is not None
                             and _time_br.time() - getattr(
                                 _bridge_fn, '_last_remb_ts', 0.0) >= 1.0):
                         _bridge_fn._last_remb_ts = _time_br.time()
-                        try:
-                            _remb_raw = build_remb(
+                        if _send_video_remb(
+                                _remb_send,
+                                getattr(_bridge_fn, '_pli_tx_sess', None),
                                 _CAM_RTCP_SENDER_SSRC,
-                                [_bridge_fn._cam_video_ssrc],
-                                REMB_TARGET_BPS)
-                            _remb_sess = getattr(_bridge_fn, '_pli_tx_sess', None)
-                            _remb_send(
-                                _remb_sess.protect_rtcp(_remb_raw)
-                                if _remb_sess is not None else _remb_raw)
-                            if not getattr(_bridge_fn, '_remb_logged', False):
-                                _bridge_fn._remb_logged = True
-                                _status(
-                                    f"SDES: sent REMB {REMB_TARGET_BPS // 1000} kbps"
-                                    f" for video SSRC"
-                                    f" 0x{_bridge_fn._cam_video_ssrc:08x}")
-                        except Exception:
-                            _LOGGER.debug(
-                                "camera %s: swallowed exception in %s",
-                                getattr(self, "device_id", "?"), '_remb',
-                                exc_info=True)
+                                _bridge_fn._cam_video_ssrc,
+                                REMB_TARGET_BPS,
+                        ) and not getattr(_bridge_fn, '_remb_logged', False):
+                            _bridge_fn._remb_logged = True
+                            _status(
+                                f"SDES: sent REMB {REMB_TARGET_BPS // 1000} kbps"
+                                f" for video SSRC"
+                                f" 0x{_bridge_fn._cam_video_ssrc:08x}")
 
                     # TMMBR: a BOUND, where REMB above is an ESTIMATE.  Two
                     # different RFC 5104 / 4585 messages, and this firmware can
@@ -4236,17 +4259,23 @@ class _SdesOpenMixin:
                     # every bitrate control tried on this camera so far has
                     # been acked and ignored, and an unmeasured one must not
                     # reach the four cameras that stream fine today.
+                    # Same cost ordering: the per-session bps attr is the
+                    # one cheap read the off-default pays; the cadence gate
+                    # runs before _tmmbr_ready so the readiness math and the
+                    # sender lookup happen at most once a second, not per
+                    # packet, and one time.time() serves both checks.
                     _tmmbr_bps = getattr(_bridge_fn, '_tmmbr_bps', None)
-                    _tmmbr_send = getattr(_bridge_fn, '_send_to_cam', None)
-                    if (_tmmbr_bps and _tmmbr_send is not None
+                    if (_tmmbr_bps
                             and hasattr(_bridge_fn, '_cam_video_ssrc')
+                            and (_tmmbr_now := _time_br.time()) - getattr(
+                                _bridge_fn, '_last_tmmbr_ts', 0.0) >= 1.0
                             and _tmmbr_ready(
                                 getattr(_bridge_fn, '_first_video_ts', None),
-                                _time_br.time(),
+                                _tmmbr_now,
                                 getattr(_bridge_fn, '_tmmbr_after_s', 0.0))
-                            and _time_br.time() - getattr(
-                                _bridge_fn, '_last_tmmbr_ts', 0.0) >= 1.0):
-                        _bridge_fn._last_tmmbr_ts = _time_br.time()
+                            and (_tmmbr_send := getattr(
+                                _bridge_fn, '_send_to_cam', None)) is not None):
+                        _bridge_fn._last_tmmbr_ts = _tmmbr_now
                         if _send_video_tmmbr(
                                 _tmmbr_send,
                                 getattr(_bridge_fn, '_pli_tx_sess', None),
@@ -5477,23 +5506,24 @@ class _SdesOpenMixin:
                                         '!I', _bpkt, 8)[0]
                                 _bridge_fn._cam_srtp_src  = _bsrc
                                 _bridge_fn._cam_srtp_sock = _bs
-                                # Publish the relay-aware sender so the RTCP
-                                # cadence (which runs outside this loop and has
-                                # no socket/peer in scope) can reach the camera
-                                # the same way the NACK does.  Rebuilt only when
-                                # the address changes: this runs ~300x/s per
-                                # camera, which is why _nack_on is resolved once
-                                # per session rather than read per packet.
                                 if getattr(_bridge_fn, '_first_video_ts',
                                            None) is None:
                                     _bridge_fn._first_video_ts = _time_br.time()
-                                if getattr(_bridge_fn, '_send_to_cam_src',
-                                           None) != _bsrc:
-                                    _bridge_fn._send_to_cam_src = _bsrc
-                                    _bridge_fn._send_to_cam = (
-                                        lambda _d, _s=_bs, _a=_bsrc,
-                                        _p=_br_cam_peer: _br_send_to_cam(
-                                            _s, _d, _a, _p))
+                                # Publish the relay-aware sender so the RTCP
+                                # cadence blocks (which have no socket/peer in
+                                # scope) can reach the camera the way the NACK
+                                # does.  This branch runs ONCE per session (it
+                                # sits inside the first-video gate), so the
+                                # sender is frozen at the first video packet's
+                                # source - the same adoption `_cam_srtp_src`
+                                # has always used.  A 1 Hz cadence send to a
+                                # stale address after a mid-session address
+                                # change just drops; the NACK path keeps its
+                                # own per-event binding for exactly that case.
+                                _bridge_fn._send_to_cam = (
+                                    lambda _d, _s=_bs, _a=_bsrc,
+                                    _p=_br_cam_peer: _br_send_to_cam(
+                                        _s, _d, _a, _p))
                                 # Schedule immediate PLI so IDR+SPS arrives in
                                 # the analyzeduration window.
                                 _bridge_fn._last_pli_ts = 0.0

{python_aidot_cameras-1.0.0b28 → python_aidot_cameras-1.0.0b30}/aidot_cameras/cloud_auth.py

@@ -18,7 +18,6 @@ import asyncio
 import json
 import logging
 import os
-import sys
 import tempfile
 
 import aiohttp
@@ -27,7 +26,25 @@ from .client import AidotClient
 
 _LOGGER = logging.getLogger("aidot.cloud_auth")
 
-DEFAULT_COUNTRY = os.environ.get("AIDOT_COUNTRY", "US")
+
+def _default_country() -> str:
+    """The AIDOT_COUNTRY fallback, read at CALL time.
+
+    This used to be a module-level constant bound at import, which made a
+    caller's later os.environ tweak silently ineffective: a creds file with a
+    non-US country logged in as US on the password path. Reading it when the
+    client is built keeps environment and parameters equivalent.
+    """
+    return os.environ.get("AIDOT_COUNTRY", "US")
+
+
+class CloudAuthUnavailable(RuntimeError):
+    """No usable credentials: no readable token file and no username/password.
+
+    Raised instead of ``sys.exit`` so library-side callers (the release
+    validator among them) keep their own error reporting; the go2rtc CLI
+    translates it to an exit in ``__main__``.
+    """
 
 
 def _read_token_file(path: str) -> dict:
@@ -85,19 +102,39 @@ def _install_token_cache(client: AidotClient, path: str) -> None:
     client.set_token_fresh_cb(_cb)
 
 
-async def _make_client(session: aiohttp.ClientSession) -> AidotClient:
-    """Authenticate to the AiDot cloud from the environment.
+async def _make_client(
+    session: aiohttp.ClientSession,
+    *,
+    username: "str | None" = None,
+    password: "str | None" = None,
+    country: "str | None" = None,
+) -> AidotClient:
+    """Authenticate to the AiDot cloud, from parameters or the environment.
 
     Prefers a stored token (AIDOT_TOKEN_FILE) - the same login_info dict the HA
     integration persists - which carries access/refresh tokens so no password
     round-trip is needed.  Falls back to username/password login otherwise.  In
     both cases, if AIDOT_TOKEN_FILE is set we register a write-back cache so
     rotations persist.
+
+    Credentials a caller already holds are passed explicitly; each parameter
+    left as None falls back to its environment variable.  The parameters exist
+    so a caller never has to publish secrets into ``os.environ`` (where every
+    spawned child inherits them) just to reach this function - the shim that
+    did exactly that also carried a dead country assignment, because the old
+    module-level default was bound at import time.
+
+    Raises :class:`CloudAuthUnavailable` when neither a readable token file
+    nor a username/password pair is available.
     """
     loop = asyncio.get_running_loop()
     token_file = os.environ.get("AIDOT_TOKEN_FILE")
-    username = os.environ.get("AIDOT_USERNAME")
-    password = os.environ.get("AIDOT_PASSWORD")
+    if username is None:
+        username = os.environ.get("AIDOT_USERNAME")
+    if password is None:
+        password = os.environ.get("AIDOT_PASSWORD")
+    if country is None:
+        country = _default_country()
 
     if token_file and os.path.exists(token_file):
         try:
@@ -113,14 +150,14 @@ async def _make_client(session: aiohttp.ClientSession) -> AidotClient:
             return client
 
     if not username or not password:
-        sys.exit(
+        raise CloudAuthUnavailable(
             "Set AIDOT_TOKEN_FILE, or AIDOT_USERNAME and AIDOT_PASSWORD, in the "
             "environment."
         )
 
     client = AidotClient(
         session=session,
-        country_code=DEFAULT_COUNTRY,
+        country_code=country,
         username=username,
         password=password,
     )

{python_aidot_cameras-1.0.0b28 → python_aidot_cameras-1.0.0b30}/pyproject.toml

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

{python_aidot_cameras-1.0.0b28 → python_aidot_cameras-1.0.0b30/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 1.0.0b28
+Version: 1.0.0b30
 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-1.0.0b28 → python_aidot_cameras-1.0.0b30}/tests/test_offer_bandwidth_line.py

@@ -132,8 +132,11 @@ def test_applying_a_ceiling_leaves_a_receipt_in_the_log():
 
     src = (pathlib.Path(__file__).resolve().parents[1] / "aidot_cameras"
            / "camera" / "sdes_open.py").read_text()
-    m = re.search(r"_bw_kbps\s*=\s*_sdes_offer_bandwidth_kbps\(\)\s*\n"
-                  r"\s*if _bw_kbps and _status:\s*\n"
+    m = re.search(r"if _bw_kbps and _status:\s*\n"
                   r'\s*_status\(f"[^"]*b=AS:\{_bw_kbps\}"\)', src)
     assert m, ("applying a receive-bandwidth ceiling must emit a status "
                "receipt naming the value that reached the offer")
+    assert src.count("_sdes_offer_bandwidth_kbps()") == 2, (
+        "the knob must be read ONCE per offer (its definition plus one call "
+        "site); a second read lets the receipt disagree with the SDP actually "
+        "sent, which is the false-receipt trap the receipt exists to close")

{python_aidot_cameras-1.0.0b28 → python_aidot_cameras-1.0.0b30}/tests/test_remb_goes_out_the_relay_aware_sender.py

@@ -50,12 +50,17 @@ _SRC = (pathlib.Path(__file__).resolve().parents[1] / "aidot_cameras"
 
 
 def _remb_block() -> str:
-    """The REMB send, from its guard to the end of its exception handler."""
+    """The REMB cadence block: its guard through to the TMMBR block's start.
+
+    Sliced anchor-to-structural-terminator rather than anchor+N characters -
+    a fixed-width window goes quietly vacuous when comments grow, and a
+    vacuous window makes the negative assertions below pass without guarding
+    anything.
+    """
     src = _SRC.read_text()
-    # Anchor on the sender resolution, which sits just above the guard, so the
-    # window covers how the sender is obtained as well as how it is used.
-    start = src.index("_remb_send = getattr(")
-    return src[start:start + 1400]
+    start = src.index("if (REMB_TARGET_BPS > 0")
+    end = src.index("_tmmbr_bps = getattr(", start)
+    return src[start:end]
 
 
 def test_remb_does_not_write_to_the_raw_socket():
@@ -77,15 +82,19 @@ def test_remb_does_not_fall_back_to_the_socket_when_the_sender_is_missing():
     second; falling back to `sendto` costs correctness on every relayed camera.
     """
     block = _remb_block()
-    assert re.search(r"_remb_send\s*=\s*getattr\(\s*_bridge_fn,\s*'_send_to_cam',\s*None\s*\)",
-                     block), "the sender must be resolved with a None default"
-    assert re.search(r"_remb_send is not None", block), (
-        "the guard must require the relay-aware sender, not fall back")
+    assert re.search(
+        r"_remb_send\s*:=\s*getattr\(\s*\n?\s*_bridge_fn,\s*'_send_to_cam',"
+        r"\s*None\s*\)+\s*\)?\s*is not None", block), (
+        "the guard must resolve the relay-aware sender with a None default "
+        "and require it, not fall back to a socket")
 
 
 def test_remb_uses_the_keyed_sender_ssrc_constant():
     block = _remb_block()
     assert "_CAM_RTCP_SENDER_SSRC" in block
+    assert "_send_video_remb(" in block, (
+        "REMB must go through its helper like NACK and TMMBR do; the inline "
+        "copy is where the raw-socket bug hid")
     assert "0xAB12CD34" not in block, (
         "the SRTP TX policy is keyed on _CAM_RTCP_SENDER_SSRC; a literal here "
         "drifts and the camera drops the packet")

{python_aidot_cameras-1.0.0b28 → python_aidot_cameras-1.0.0b30}/tests/test_sdes_tmmbr_bridge.py

@@ -95,9 +95,12 @@ def test_the_call_site_uses_the_relay_aware_sender_and_the_keyed_ssrc():
              if src.startswith("_send_video_tmmbr(", i)
              and not src[:i].endswith("def ")]
     assert calls, "the bridge must actually send the TMMBR it can build"
-    # Widen behind the call too: the sender is resolved into a local a few
-    # lines above (_tmmbr_send = getattr(_bridge_fn, '_send_to_cam', None)).
-    args = src[max(0, calls[0] - 900):calls[0] + 400]
+    # Window from the cadence block's start to the PLI block that follows,
+    # so it covers how the sender is resolved as well as how it is used -
+    # structural terminators, not a fixed character count that goes vacuous
+    # as comments grow.
+    start = src.index("_tmmbr_bps = getattr(_bridge_fn, '_tmmbr_bps', None)")
+    args = src[start:src.index("_pli_done", start)]
     assert "_cam_srtp_sock.sendto" not in args, (
         "a raw socket write is silently inert on a TURN-relayed session -- "
         "use the bridge's relay-aware sender, as the NACK path does")
@@ -164,8 +167,8 @@ def test_the_bridge_gates_the_send_on_it():
 
     src = (pathlib.Path(__file__).resolve().parents[1] / "aidot_cameras"
            / "camera" / "sdes_open.py").read_text()
-    i = src.index("_tmmbr_send = getattr(_bridge_fn, '_send_to_cam', None)")
-    window = src[i:i + 900]
+    i = src.index("_tmmbr_bps = getattr(_bridge_fn, '_tmmbr_bps', None)")
+    window = src[i:src.index("_pli_done", i)]
     assert "_tmmbr_ready(" in window, (
         "the TMMBR cadence must consult _tmmbr_ready, or AIDOT_SDES_TMMBR_AFTER_S "
         "does nothing and the measurement is between-session again")
@@ -197,8 +200,14 @@ def test_the_switches_are_resolved_once_per_session_not_per_packet():
     assert "_sdes_tmmbr_after_s()" in setup
 
     # And the cadence reads the resolved value rather than the environment.
-    i = src.index("_tmmbr_send = getattr(_bridge_fn, '_send_to_cam', None)")
-    cadence = src[i - 600:i + 900]
+    i = src.index("_tmmbr_bps = getattr(_bridge_fn, '_tmmbr_bps', None)")
+    cadence = src[i:src.index("_pli_done", i)]
     assert "_sdes_tmmbr_bps()" not in cadence, (
         "the cadence must not call os.environ; it runs on the packet loop")
     assert "_sdes_tmmbr_after_s()" not in cadence
+    # Cost ordering inside the guard: the once-a-second cadence gate must sit
+    # BEFORE the readiness math and the sender lookup, or both run per packet.
+    assert cadence.index("_last_tmmbr_ts") < cadence.index("_tmmbr_ready("), (
+        "the 1s cadence gate must run before _tmmbr_ready")
+    assert cadence.index("_tmmbr_ready(") < cadence.index("_send_to_cam"), (
+        "the sender lookup must be the last, rarest check")

{python_aidot_cameras-1.0.0b28 → python_aidot_cameras-1.0.0b30}/tests/test_self_peer_is_an_address_not_an_ip.py

@@ -34,7 +34,7 @@ from aidot_cameras.camera.sdes_open import (
 )
 
 LOCAL = "192.168.7.2"
-PUBLIC = "173.53.36.206"
+PUBLIC = "203.0.113.7"
 OURS = (41000, 41002)          # the ports our own srflx candidates advertise