python-aidot-cameras 0.15.7__tar.gz → 0.16.0__tar.gz

{python_aidot_cameras-0.15.7/python_aidot_cameras.egg-info → python_aidot_cameras-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.7
+Version: 0.16.0
 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.7 → python_aidot_cameras-0.16.0}/aidot_cameras/camera/client.py

@@ -365,6 +365,18 @@ def _is_self_referential_source(source: str, stream_name: str) -> bool:
     return path == stream_name
 
 
+#: Packets the serve's demuxer may hold while it waits for a gap to fill.  A
+#: keyframe on an A001064 is 146-190 KB - roughly 130 packets - so anything
+#: smaller than a few hundred cannot ride out a burst that arrives out of order.
+#: Env-overridable because the right value depends on the link, not on us.
+_SERVE_REORDER_QUEUE = int(os.environ.get("AIDOT_SERVE_REORDER_QUEUE", "500"))
+
+#: How long (microseconds) the demuxer waits for a missing packet before moving
+#: on.  Bounded on purpose: waiting forever turns loss into a stall, which is the
+#: failure this is meant to prevent.
+_SERVE_MAX_DELAY_US = int(os.environ.get("AIDOT_SERVE_MAX_DELAY_US", "500000"))
+
+
 def _build_sdes_serve_cmd(
     *,
     sdp_path: str,
@@ -470,9 +482,26 @@ def _build_sdes_serve_cmd(
         # 2 s analyzeduration: the camera sends SPS+PPS+IDR in the first burst;
         # 15 s consumed nearly all packets during analysis.  PLI re-arms an IDR
         # every 5 s so parameters always re-arrive.
-        "-fflags", "+nobuffer+genpts",
+        #
+        # ``discardcorrupt`` is the loss half of this: both ends of this path are
+        # wireless (the camera, and typically the host), so RTP arrives with real
+        # gaps.  Measured on the reference install: `RTP: missed N packets` with
+        # ZERO drops on every socket in the path, which means the packets were
+        # lost before they ever reached the box.  Without this ffmpeg passes the
+        # damaged frame downstream and then backs its input queue up behind the
+        # reordering it thinks it needs - "max delay reached. need to consume
+        # packet" - and the serve eventually dies, taking every viewer with it.
+        # A brief artefact is a far better outcome than a dropped stream.
+        "-fflags", "+nobuffer+genpts+discardcorrupt",
         "-analyzeduration", "2000000",
         "-probesize", "500000",
+        # Reordering headroom.  The default (-1) leaves the demuxer with almost
+        # none, so a burst that arrives out of order reads as loss.  A keyframe
+        # here is 146-190 KB - about 130 packets - so the queue has to be able to
+        # hold more than one of them, and max_delay bounds how long it will wait
+        # before giving up on a gap rather than stalling the pipeline.
+        "-reorder_queue_size", str(_SERVE_REORDER_QUEUE),
+        "-max_delay", str(_SERVE_MAX_DELAY_US),
         "-i", sdp_path,
         *dest_args,
     ]

{python_aidot_cameras-0.15.7 → python_aidot_cameras-0.16.0}/aidot_cameras/camera/protocol.py

@@ -8,6 +8,7 @@ imports client.py -- the import edge is one-way (client -> protocol).
 """
 
 import asyncio
+import concurrent.futures as _cfutures
 import hashlib
 import ipaddress
 import json
@@ -22,7 +23,7 @@ import tempfile
 import threading
 import time
 import zlib
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, NamedTuple
 
 from .constants import TALK_PCM_FRAME_BYTES, TALK_PCM_RATE
 
@@ -2176,3 +2177,233 @@ def _dedup_bundle_candidates(sdp: str) -> str:
         else:
             result.extend(ln for ln in sec if not ln.startswith('a=candidate:'))
     return '\r\n'.join(result)
+
+
+#: Header of an AVIO control frame: seq, command, timestamp(ms), payload length,
+#: reserved, then 4 bytes of padding.  Same layout we already build when sending.
+_AVIO_RESP_HDR = struct.Struct("<IIqII4x")
+
+#: Bytes of header before an AVIO payload begins.  Exported because the SDES
+#: receive path has to walk past one frame to reach the next in the same chunk.
+AVIO_HDR_LEN = _AVIO_RESP_HDR.size
+
+
+class AvioResponse(NamedTuple):
+    """A decoded AVIO control response."""
+
+    seq: int
+    command: int
+    payload: bytes
+
+
+def parse_avio_response(frame: bytes) -> "Optional[AvioResponse]":
+    """Decode an AVIO control response, or None if this is not a valid one.
+
+    Returns None rather than raising: this runs on the bridge's receive path,
+    where anything can arrive, and a malformed frame must be ignored rather than
+    kill the loop. A declared length that overruns the buffer is rejected too -
+    trusting it would hand the caller a truncated payload and, for example, read
+    a stream profile out of bytes the camera never sent.
+    """
+    if not frame or len(frame) < _AVIO_RESP_HDR.size:
+        return None
+    seq, command, _ts, length, _reserved = _AVIO_RESP_HDR.unpack_from(frame, 0)
+    body = frame[_AVIO_RESP_HDR.size:]
+    if len(body) < length:
+        return None
+    return AvioResponse(seq=seq, command=command, payload=body[:length])
+
+
+class _AvioWaiter:
+    """A single outstanding question, handed back by ``AvioResponseRouter.expect``.
+
+    Built on a ``concurrent.futures.Future`` rather than an ``asyncio`` one on
+    purpose: the reply is dispatched from the SDES bridge thread while the
+    caller awaits on the event loop, and setting an asyncio future's result from
+    a foreign thread does not wake the awaiting coroutine - the camera would
+    look silent.
+    """
+
+    def __init__(self, router: "AvioResponseRouter", command: int) -> None:
+        self._router  = router
+        self._command = command
+        self._future  = _cfutures.Future()
+
+    def cancel(self) -> None:
+        """Withdraw the question - used when the command could not be sent."""
+        self._router._forget(self)
+
+    async def result(self, timeout: float) -> "Optional[AvioResponse]":
+        """The camera's reply, or None if it did not answer within ``timeout``.
+
+        None is a real answer, not an error: this firmware may not implement a
+        response for every command we send, and a control call must never block
+        a view while we find out.
+        """
+        if self._future.done():
+            # A wait that timed out cancels its own wrapper, and that
+            # cancellation can propagate down to this future - asking again
+            # would then raise where the first call returned None.
+            if self._future.cancelled():
+                return None
+            try:
+                return self._future.result()
+            except Exception:
+                return None
+        try:
+            return await asyncio.wait_for(
+                asyncio.wrap_future(self._future), timeout
+            )
+        except TimeoutError:
+            # Stop listening.  _avio_cmd runs on the keepalive path, so a
+            # registration left behind on every unanswered command would grow
+            # for as long as the session lives.
+            self._router._forget(self)
+            return None
+        except asyncio.CancelledError:
+            # Cancellation is the caller's task being stopped (entity teardown,
+            # config-entry unload), NOT the camera declining to answer.  Drop
+            # the registration, then let it through: swallowing it would leave
+            # the caller running inside a task the loop has already given up on.
+            self._router._forget(self)
+            raise
+
+
+class AvioResponseRouter:
+    """Match inbound AVIO responses to the commands that asked for them.
+
+    The control channel also carries traffic nobody asked for (session-mode
+    notifications, track switches), so "the next frame in" is not the answer to
+    the last question out.  Register interest with ``expect()`` *before* sending,
+    then await the waiter; ``dispatch()`` is safe to call from the bridge thread
+    and never raises or blocks it.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._waiting: "dict[int, list[_AvioWaiter]]" = {}
+
+    def expect(self, command: int) -> _AvioWaiter:
+        """Register interest in the next response carrying ``command``.
+
+        Call this before sending the request: the camera can answer before the
+        sender returns, and a registration made afterwards would miss the reply.
+        """
+        waiter = _AvioWaiter(self, command)
+        with self._lock:
+            self._waiting.setdefault(command, []).append(waiter)
+        return waiter
+
+    def dispatch(self, frame: bytes) -> bool:
+        """Hand ``frame`` to whoever is waiting for it.
+
+        True if it answered an outstanding question.  False - not an error - for
+        junk, for a command nobody asked about, and for a retransmitted copy of
+        a reply already delivered.
+        """
+        try:
+            resp = parse_avio_response(frame)
+            if resp is None:
+                return False
+            with self._lock:
+                queue = self._waiting.get(resp.command)
+                waiter = None
+                while queue:
+                    candidate = queue.pop(0)
+                    if not candidate._future.done():
+                        waiter = candidate
+                        break
+                if queue is not None and not queue:
+                    self._waiting.pop(resp.command, None)
+            if waiter is None:
+                return False
+            waiter._future.set_result(resp)
+            return True
+        except Exception:
+            # Runs inline on the bridge's receive path; a bad frame must never
+            # take the media loop down with it.
+            return False
+
+    def _forget(self, waiter: "_AvioWaiter") -> None:
+        with self._lock:
+            queue = self._waiting.get(waiter._command)
+            if not queue:
+                return
+            try:
+                queue.remove(waiter)
+            except ValueError:
+                return
+            if not queue:
+                self._waiting.pop(waiter._command, None)
+
+
+def _avio_cmd_id(frame: bytes) -> "Optional[int]":
+    """The command id of an AVIO frame, or None if it does not look like one.
+
+    For the receive-path logs.  Which ids this firmware actually sends is not
+    documented anywhere we trust - the list we work from was assembled from
+    frames seen on the wire - so naming them as they arrive is what turns the
+    next question into a log grep instead of another live session.
+    """
+    resp = parse_avio_response(bytes(frame))
+    return None if resp is None else resp.command
+
+
+#: How long a control call waits for the camera before reporting "no reply".
+#: Short on purpose: these run behind Home Assistant service calls, and a
+#: firmware that implements the request but not the response must not be able to
+#: hold up a view while we find that out.
+AVIO_RESPONSE_TIMEOUT_S = 2.0
+
+
+class AvioRequestMixin:
+    """Ask an AVIO command and wait for the camera's reply.
+
+    Mixed into both session types.  ``_avio_cmd`` itself is left exactly as it
+    was - fire-and-forget, synchronous, returns a bool - because every camera on
+    both transports goes through it, for the speaker, the keepalive heartbeat
+    and resolution alike.  Wanting an answer is opt-in and additive.
+
+    A session that mixes this in must create its router in ``__init__``:
+    dispatch arrives from the bridge thread and creating one lazily could race
+    with the event loop and lose the reply to a second router.
+    """
+
+    _avio_responses: "AvioResponseRouter"
+
+    def dispatch_avio_frame(self, frame: bytes) -> bool:
+        """Offer an inbound control frame to whoever is waiting for it.
+
+        Called from the transports' receive paths (the DTLS DataChannel message
+        handler, the SDES bridge thread).  False - not an error - when nothing
+        was waiting for it, which is the common case: the camera sends session
+        notifications and track switches nobody asked for.
+        """
+        return self._avio_responses.dispatch(frame)
+
+    async def async_avio_request(
+        self,
+        cmd: int,
+        payload: bytes = b"",
+        *,
+        response_cmd: int,
+        timeout: float = AVIO_RESPONSE_TIMEOUT_S,
+    ) -> "Optional[AvioResponse]":
+        """Send ``cmd`` and return the camera's ``response_cmd`` reply, or None.
+
+        None means the camera did not answer in time.  That is a real result,
+        not a failure: this firmware may implement a request without a response,
+        and no reply at all points at the channel rather than the firmware.
+        """
+        waiter = self._avio_responses.expect(response_cmd)
+        # Registered BEFORE the send: a camera on the LAN can answer before the
+        # sending call returns, and a reply that arrives with nobody listening
+        # would be reported as silence.
+        try:
+            sent = self._avio_cmd(cmd, payload)
+        except Exception:
+            sent = False
+        if not sent:
+            waiter.cancel()
+            return None
+        return await waiter.result(timeout)

{python_aidot_cameras-0.15.7 → python_aidot_cameras-0.16.0}/aidot_cameras/camera/sdes.py

@@ -10,11 +10,12 @@ import logging
 from typing import Callable, Optional
 
 from .constants import SDES_TALK_PUMP_IDLE_TICK
+from .protocol import AvioRequestMixin, AvioResponseRouter
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class SdesSession:
+class SdesSession(AvioRequestMixin):
     """Active SDES-SRTP stream session managed by an ffmpeg subprocess.
 
     Obtain via ``await DeviceClient.async_open_webrtc_stream(...)`` when the
@@ -39,6 +40,7 @@ class SdesSession:
         first_video_pt=None,
         first_audio_pt=None,
         device_id=None,
+        responses=None,
     ) -> None:
         # Which camera this session belongs to, for logging only.  Optional so
         # an existing caller that does not pass it still works; the logs then
@@ -80,6 +82,11 @@ class SdesSession:
         # Mutable one-element list shared with the bridge thread.  Bridge sets
         # [0] to a callable(cmd, payload) once the SCTP channel is up.
         self._cmd_chan   = cmd_chan if cmd_chan is not None else [None]
+        # Matches inbound AVIO replies to the commands that asked for them.
+        # Created here, not lazily: the bridge thread dispatches into it.
+        self._avio_responses = (
+            responses if responses is not None else AvioResponseRouter()
+        )
         # Shared talk state (dict) for outbound two-way audio, or None when the
         # session was not opened talk-capable (offer stayed recvonly).  Populated
         # by the bridge (camera audio addr) and by async_start_talk (provider).

{python_aidot_cameras-0.15.7 → python_aidot_cameras-0.16.0}/aidot_cameras/camera/sdes_open.py

@@ -24,7 +24,10 @@ from .constants import (
 from .models import VideoFrame  # noqa: F401 - forward-ref annotation
 from .sdes import SdesSession
 from .protocol import (
+    AVIO_HDR_LEN,
+    AvioResponseRouter,
     _build_sprop,
+    parse_avio_response,
     _build_stun_binding_success_response,
     _extract_param_sets_from_rtp,
     _grab_free_port,
@@ -45,6 +48,40 @@ _LOGGER = logging.getLogger(__name__)
 _MEDIA_RCVBUF_BYTES = 4 * 1024 * 1024
 
 
+def _dispatch_sctp_avio(responses, payload) -> bool:
+    """Offer an inbound SCTP DATA payload to the AVIO response router.
+
+    This is where the camera's replies actually arrive on SDES: an encrypted
+    SCTP DATA chunk (PPID 53) on the same channel we send LIVING, the heartbeat
+    and SPEAKERSTART on - not the TUTK-audio framing the audio forward path
+    watches. Wiring only the latter is why a camera that answered SPEAKERSTART
+    in moments looked silent.
+
+    True if it answered something we were waiting for. Never raises and never
+    blocks: it runs inline on the bridge receive loop, where a bad frame must
+    not be able to take the media path down with it.
+    """
+    if responses is None or not payload:
+        return False
+    answered = False
+    try:
+        view = memoryview(payload)
+        while len(view) >= AVIO_HDR_LEN:
+            frame = parse_avio_response(bytes(view))
+            if frame is None:
+                break
+            if responses.dispatch(bytes(view)):
+                answered = True
+            # One chunk can carry more than one frame: 5377 declares a 12-byte
+            # payload and has been seen arriving in a 140-byte chunk.  Reading
+            # only the first would lose a reply batched behind a notify, which
+            # presents as the camera intermittently not answering.
+            view = view[AVIO_HDR_LEN + len(frame.payload):]
+    except Exception:
+        return answered
+    return answered
+
+
 def _widen_media_rcvbuf(sock, kind: str, device_id: str = "?") -> int:
     """Ask for a large receive buffer on a camera media socket.
 
@@ -2756,6 +2793,12 @@ class _SdesOpenMixin:
         # once the SCTP DataChannel is established.  SdesSession reads it via
         # _cmd_chan[0] to dispatch PTZ / IOCtrl commands from the main thread.
         _cmd_chan: list = [None]
+        # The other direction: matches the camera's AVIO replies to the commands
+        # that asked for them.  Created here, not in SdesSession, because the
+        # bridge thread starts dispatching into it before the session object
+        # exists; the session is handed the same instance so both sides share
+        # one registry.
+        _avio_responses = AvioResponseRouter()
         # Proc holder: set to the ffmpeg Popen object after launch so the
         # bridge thread can poll for exit without a NameError race.
         _proc_holder: list = [None]
@@ -3807,9 +3850,17 @@ class _SdesOpenMixin:
                                                     if len(_pd_plain) >= 28 else 0)
                                         _sc_cmd = (int.from_bytes(_sc_pay[4:8], 'little')
                                                    if len(_sc_pay) >= 8 else 0)
+                                        # This is where the camera's answers
+                                        # come back on SDES.  They were parsed
+                                        # and logged here long before anything
+                                        # could receive them; hand them to
+                                        # whoever asked.
+                                        _sc_answered = _dispatch_sctp_avio(
+                                            _avio_responses, _sc_pay)
                                         _status(
                                             f"SDES DC: enc DATA ppid={_sc_ppid}"
                                             f" cmd={_sc_cmd} {len(_sc_pay)}B"
+                                            f"{' (answered a request)' if _sc_answered else ''}"
                                             f" {_sc_pay[:32].hex()}"
                                         )
                                     else:
@@ -3878,6 +3929,14 @@ class _SdesOpenMixin:
                                     # f0.java:3224): the camera can send it unsolicited, and
                                     # without it here an 804 frame is misrouted as PCMA noise.
                                     _avio_cmds = {5376, 5377, 5156, 5157, 768, 769, 511, 804}
+                                    # No response dispatch here.  Measured
+                                    # 2026-08-07: the camera's replies come back
+                                    # as encrypted SCTP DATA (see
+                                    # _dispatch_sctp_avio), never in this
+                                    # framing.  Offering every audio packet to
+                                    # the router would be per-packet work on the
+                                    # media path for something that has never
+                                    # arrived on it.
                                     if _fwd_cmd not in _avio_cmds:
                                         try:
                                             _lo_a.sendto(
@@ -4964,4 +5023,5 @@ class _SdesOpenMixin:
             first_video_pt=_first_video_pt,
             first_audio_pt=_first_audio_pt,
             device_id=getattr(self, "device_id", None),
+            responses=_avio_responses,
         )

{python_aidot_cameras-0.15.7 → python_aidot_cameras-0.16.0}/aidot_cameras/camera/webrtc.py

@@ -12,10 +12,12 @@ import struct
 import time
 from typing import Any, Callable, Optional
 
+from .protocol import AvioRequestMixin, AvioResponseRouter
+
 _LOGGER = logging.getLogger(__name__)
 
 
-class WebRTCSession:
+class WebRTCSession(AvioRequestMixin):
     """Active WebRTC live-stream session for a liveType=2 AiDot camera.
 
     Obtain via ``await DeviceClient.async_open_webrtc_stream(...)``.
@@ -34,6 +36,7 @@ class WebRTCSession:
         audio_sender: Any = None,
         talk_track: Any = None,
         talk_holder: Any = None,
+        responses: Any = None,
     ) -> None:
         self._pc          = pc
         self._outgoing_q  = outgoing_q
@@ -41,6 +44,12 @@ class WebRTCSession:
         self._recorder    = recorder
         self._track_tasks = track_tasks
         self._dc          = dc  # RTCDataChannel for AVIO IOCtrl commands
+        # Matches inbound AVIO replies to the commands that asked for them.
+        # Created here, not lazily: the DataChannel message handler can
+        # dispatch from outside this constructor's thread.
+        self._avio_responses = (
+            responses if responses is not None else AvioResponseRouter()
+        )
         # Two-way audio (talk): the sendrecv audio RTCRtpSender, an idle PCMA talk
         # track, and a mutable {"provider": callable|None} holder the track reads from.
         self._audio_sender = audio_sender

{python_aidot_cameras-0.15.7 → python_aidot_cameras-0.16.0}/aidot_cameras/camera/webrtc_open.py

@@ -21,6 +21,8 @@ from .constants import _LIVE_PLAY_NOT_READY, fallback_turn_uris, stun_server_uri
 from .models import VideoFrame
 from .webrtc import WebRTCSession
 from .protocol import (
+    AvioResponseRouter,
+    _avio_cmd_id,
     _compress_sdp_for_camera,
     _dedup_bundle_candidates,
     _filter_sdp_candidates,
@@ -1729,6 +1731,12 @@ class _WebRTCOpenMixin:
                 _status(f"talk: SPEAKER{'START' if start else 'STOP'} failed:"
                         f" {_spk_exc}")
 
+        # Matches the camera's AVIO replies to the commands that asked for
+        # them.  Created here rather than in the session because the message
+        # handlers below are registered while the session does not exist yet;
+        # it is handed to the session at the end so both sides share one.
+        _avio_responses = AvioResponseRouter()
+
         # Camera-initiated DCEP path: KVS firmware on A000088 doesn't include
         # m=application in its answer SDP, suggesting the data channel may
         # actually be opened by the camera (master), not the viewer.  Hook
@@ -1748,8 +1756,10 @@ class _WebRTCOpenMixin:
             def _on_remote_dc_message(message) -> None:
                 try:
                     if isinstance(message, (bytes, bytearray)):
+                        _avio_responses.dispatch(bytes(message))
                         _status(
                             f"DC[remote:{channel.label}] RX {len(message)}B"
+                            f" cmd={_avio_cmd_id(message)}"
                             f" hex={bytes(message)[:32].hex()}"
                         )
                     else:
@@ -1874,8 +1884,10 @@ class _WebRTCOpenMixin:
             def _on_kvs_dc_message(message) -> None:
                 try:
                     if isinstance(message, (bytes, bytearray)):
+                        _avio_responses.dispatch(bytes(message))
                         _status(
                             f"DC[{_dc_label}] RX {len(message)}B"
+                            f" cmd={_avio_cmd_id(message)}"
                             f" hex={bytes(message)[:32].hex()}"
                         )
                     else:
@@ -3716,4 +3728,5 @@ class _WebRTCOpenMixin:
             audio_sender=_audio_sender,
             talk_track=_talk_track,
             talk_holder=_talk_holder,
+            responses=_avio_responses,
         )

{python_aidot_cameras-0.15.7 → python_aidot_cameras-0.16.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.15.7"
+version = "0.16.0"
 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.7 → python_aidot_cameras-0.16.0/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.7
+Version: 0.16.0
 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.7 → python_aidot_cameras-0.16.0}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -73,6 +73,9 @@ tests/test_aioice_compat.py
 tests/test_alarm_event.py
 tests/test_answer_sdp_video_pt.py
 tests/test_audio_mux_offline.py
+tests/test_avio_request.py
+tests/test_avio_response_parse.py
+tests/test_avio_response_router.py
 tests/test_backoff.py
 tests/test_battery_detection.py
 tests/test_battery_evidence_corroboration.py
@@ -133,6 +136,7 @@ tests/test_restart_cycle.py
 tests/test_retry_policy.py
 tests/test_scripts_importable.py
 tests/test_sdes_adaptive.py
+tests/test_sdes_avio_dispatch.py
 tests/test_sdes_bridge_break_gate.py
 tests/test_sdes_echo_wait_timeout.py
 tests/test_sdes_fast_liveplay.py
@@ -152,6 +156,7 @@ tests/test_sdp_narrowing_properties.py
 tests/test_sdp_payload_type_narrowing.py
 tests/test_security_hardening.py
 tests/test_serializable_login_info.py
+tests/test_serve_loss_tolerance.py
 tests/test_serve_relay.py
 tests/test_session_stats.py
 tests/test_shared_house_seam.py