webatem 2.0.2__tar.gz → 2.0.4__tar.gz

{webatem-2.0.2 → webatem-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webatem
-Version: 2.0.2
+Version: 2.0.4
 Summary: Browser-based control for Blackmagic ATEM switchers: run it, open the browser, your switchers are there
 Author: Lucas Romanenko
 License: MIT

{webatem-2.0.2 → webatem-2.0.4}/atem_control/control/consumer.py

@@ -134,10 +134,12 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
         # is sent to the ATEM exactly on the 0↔1 transitions.
         self._audio_subscribed = False
         self._meter_handler_ids: list = []
-        # The AtemProtocol object the meter handlers were registered on —
-        # a pooled re-handshake builds a NEW protocol (and a NEW ATEM
-        # session that never got SFLN), so identity change means the
-        # meters must re-arm.
+        # The AtemProtocol object the meter handlers were registered on.
+        # A transport re-handshake keeps it (and starts a new switcher
+        # session that has not had SFLN): the 'connected' handler re-arms
+        # for that. Only a fresh connect() on this connection, after its
+        # worker died, builds a new protocol; the poll loop's identity
+        # check re-registers the handlers on it.
         self._meter_protocol = None
         self._meter_loop = None
         self._meter_batch_strips: dict = {}  # strip_id → latest payload this tick
@@ -649,8 +651,10 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
             # SYN handshakes after a cable yank, so ``is_connected`` stays
             # True for a while even with no live ATEM). The real signal is
             # ``build_full_state`` returning ``is_connected: False``, which
-            # fires when atemwire's protocol layer cleared mixerstate after
-            # giving up on the failed reconnects.
+            # fires when atemwire's protocol layer clears mixerstate: 5 s
+            # after the switcher's last packet, when the transport starts
+            # re-handshaking (and keeps at it). Since bmdwire 1.4.0 that
+            # holds even while this side keeps sending (bmdwire#11).
             #
             # Starts at ``None`` (unknown). The first observation seeds it
             # without firing a notification — otherwise the first poll
@@ -674,9 +678,11 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
                         await self._auto_disconnect_inactive()
                         break
 
-                # Meters must survive a pooled in-place reconnect
-                # (new protocol object + new ATEM session) — cheap
-                # identity check, no-op when nothing changed.
+                # Meters must survive a connection that built a new
+                # protocol object (a fresh connect() after the worker
+                # died). Cheap identity check, a no-op when nothing
+                # changed. A transport re-handshake keeps the protocol
+                # and is re-armed by the 'connected' handler instead.
                 self._rearm_audio_meters_if_reconnected()
 
                 # Get current state
@@ -685,8 +691,8 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
                 t_build = time.monotonic() - t0
 
                 # ATEM-side reachability transition: atemwire's protocol clears
-                # mixerstate when it gives up on reconnects, which makes
-                # build_full_state return ``{'is_connected': False}``.
+                # mixerstate when the transport starts re-handshaking, which
+                # makes build_full_state return ``{'is_connected': False}``.
                 # Treat that as "ATEM dropped mid-session" and notify the
                 # frontend so the disconnect banner
                 # appears. Without this, the worker keeps retrying SYN
@@ -982,6 +988,13 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
                           self._on_master_meter)
         self._meter_handler_ids.append(('change:fairlight-master-levels', mid))
 
+        # A new switcher session (the transport re-handshaking after a
+        # silence) has not had SFLN, so it streams no meters until it
+        # gets one. It keeps this protocol object, so the identity check
+        # can't see it: re-arm on the session's 'connected' event.
+        cid = protocol.on('connected', self._on_session_connected)
+        self._meter_handler_ids.append(('connected', cid))
+
         # Per-IP subscriber refcount. First subscriber tells the ATEM to
         # start streaming meters — without SFLN(True) the ATEM emits zero
         # FMLv/FDLv packets even with handlers registered.
@@ -999,14 +1012,17 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
         self._meter_protocol = protocol
 
     def _rearm_audio_meters_if_reconnected(self):
-        """A pooled re-handshake builds a NEW AtemProtocol and a NEW
-        ATEM session — the meter handlers were registered on the old
-        object and the new session never received SFLN(enable), so the
-        meters froze at the old levels (looking live) until every
-        subscriber unsubscribed. Detect the protocol identity change from
-        the poll loop and re-arm: re-register the handlers on the new
-        protocol and re-send the enable (idempotent on the ATEM; the
-        per-IP refcount is untouched — this consumer never unsubscribed)."""
+        """Re-arm the meters on a NEW AtemProtocol. A transport
+        re-handshake does not build one: it keeps the protocol and is
+        re-armed by ``_on_session_connected``. Only a fresh ``connect()``
+        on this connection after its worker died does, and then the meter
+        handlers are still on the old object and the new session never
+        received SFLN(enable), so the meters would freeze at the old
+        levels (looking live) until every subscriber unsubscribed. Detect
+        the protocol identity change from the poll loop and re-arm:
+        re-register the handlers on the new protocol and re-send the
+        enable (idempotent on the ATEM; the per-IP refcount is untouched,
+        since this consumer never unsubscribed)."""
         if not self._audio_subscribed:
             return
         protocol = getattr(self.connection, 'protocol', None) if self.connection else None
@@ -1019,12 +1035,31 @@ class ATEMConsumer(ATEMConnectionLoggingMixin, ATEMStateMixin, AsyncWebsocketCon
         self._meter_handler_ids.append(('change:fairlight-meter-levels', sid))
         mid = protocol.on('change:fairlight-master-levels', self._on_master_meter)
         self._meter_handler_ids.append(('change:fairlight-master-levels', mid))
+        cid = protocol.on('connected', self._on_session_connected)
+        self._meter_handler_ids.append(('connected', cid))
         self._meter_protocol = protocol
         try:
             enable_fairlight_levels(self.connection, enable=True)
         except Exception as e:
             logger.warning(f"SFLN re-arm failed: {e}")
 
+    def _on_session_connected(self):
+        """Handler for the protocol's 'connected' event, which fires when
+        a new switcher session's state dump is complete: after a transport
+        re-handshake on the same protocol object (webatem#38). That session
+        has not had SFLN, so re-send it. Runs on the connection's worker
+        thread; ``ATEMConnection.send`` is thread-safe. Every subscribed
+        consumer sends one, which is idempotent on the switcher; the
+        per-IP refcount only gates the 0→1 send at subscribe time, so with
+        two tabs open a re-subscribe alone would send nothing."""
+        if not self._audio_subscribed or self.connection is None:
+            return
+        logger.info(f"Re-arming audio meters for the new switcher session ({self.current_ip})")
+        try:
+            enable_fairlight_levels(self.connection, enable=True)
+        except Exception as e:
+            logger.warning(f"SFLN re-arm after reconnect failed: {e}")
+
     def _unsubscribe_audio_meters(self):
         """Idempotent. Unregister per-consumer meter listeners and
         decrement the per-IP refcount; send SFLN(enable=False) on 1→0

{webatem-2.0.2 → webatem-2.0.4}/atem_control/uploader.py

@@ -65,6 +65,10 @@ CONNECT_RETRY_DELAY = 2.0
 UPLOAD_TIMEOUT = 90.0
 HASH_SETTLE_TIMEOUT = 10.0
 REUPLOAD_SETTLE = 1.0
+# A tally check that finds no switcher state (the session re-handshaking after
+# a drop, or its new dump still arriving) waits this long for the state before
+# it refuses the upload: the budget the connect gives the first dump.
+STATE_READY_TIMEOUT = CONNECTION_TIMEOUT
 
 # Tally cycle-wait timings + the shared cold->hot->cold loop live in
 # ``content_change.tally`` so the media-pool and HyperDeck paths can't drift.
@@ -200,7 +204,55 @@ def _source_on_air(mixerstate, ids: set) -> bool:
     return False
 
 
-def _is_slot_safe(protocol, slot_0_indexed: int) -> bool:
+class _StateNotReady(Exception):
+    """The switcher's state did not come back within STATE_READY_TIMEOUT, so
+    nothing can say the slot is off air. ``_upload_one`` refuses the item."""
+
+
+def _pooled(conn) -> bool:
+    """A pooled ``ATEMConnection`` (how a host calls ``_is_slot_safe``), not
+    the uploader's own ``AtemProtocol``: its worker thread pumps the loop and
+    tracks the session, so it is asked rather than pumped."""
+    return hasattr(conn, 'is_connected')
+
+
+def _state_ready(conn) -> bool:
+    """The switcher's state is there to read: its dump has finished and
+    carried a video mode, the test ``atemwire.ready.wait_ready`` uses. A
+    dropped session empties ``mixerstate`` while the transport re-handshakes
+    in place, and the new dump refills it field by field, so anything short of
+    this can be missing exactly the field that says the slot is on air."""
+    if 'video-mode' not in conn.mixerstate:
+        return False
+    if _pooled(conn):
+        # is_ready (bmdwire >= 1.3) is False through a re-handshake, when
+        # is_connected stays True; the media-pool watcher asks the same.
+        return bool(getattr(conn, 'is_ready', conn.is_connected))
+    # Set at the end-of-dump marker, cleared on a drop.
+    return bool(getattr(conn, 'initialized', False))
+
+
+def _await_state(conn, timeout: float,
+                 is_cancelled: Optional[Callable[[], bool]] = None) -> bool:
+    """Wait until the state is ready (True), or until ``timeout`` seconds pass
+    or ``is_cancelled`` says so (False). A bare protocol is pumped, ticked so
+    a quiet wire cannot hold one pump past the deadline; a pooled connection's
+    own worker is pumping it already."""
+    deadline = time.monotonic() + timeout
+    while not _state_ready(conn):
+        if time.monotonic() >= deadline:
+            return False
+        if is_cancelled is not None and is_cancelled():
+            return False
+        if _pooled(conn):
+            time.sleep(0.02)
+        else:
+            ticked_pump(conn, idle_sleep=0.02)
+    return True
+
+
+def _is_slot_safe(protocol, slot_0_indexed: int,
+                  is_cancelled: Optional[Callable[[], bool]] = None) -> bool:
     """Safe to overwrite a media-pool slot when no media player currently
     showing that slot (as a still) is live on PROGRAM output.
 
@@ -214,7 +266,24 @@ def _is_slot_safe(protocol, slot_0_indexed: int) -> bool:
     Only if tally hasn't arrived yet (rare — it's in the connect state-dump) do
     we fall back to an ME1 program-path reconstruction, so we neither overwrite
     blind nor hang waiting for tally.
+
+    Only a state that is there can say a slot is safe. An empty one (the
+    session reconnecting) or a dump still arriving has no media players and no
+    tally in it, which reads as "nothing on air"; until 2.0.4 that let an
+    upload through into a live slot. So the check first waits up to
+    STATE_READY_TIMEOUT for the state and raises ``_StateNotReady`` if it does
+    not come back. A cancel ends that wait the same way; the caller checks for
+    the cancel first. It raises rather than answering False because "cannot
+    tell" means different things to different callers: to an upload it is a
+    refusal, to a host watching for a slot to go on air it is "not live".
     """
+    if not _await_state(protocol, STATE_READY_TIMEOUT, is_cancelled):
+        raise _StateNotReady(
+            f"switcher state not ready after {STATE_READY_TIMEOUT:.0f}s "
+            f"(session reconnecting); cannot confirm slot {slot_0_indexed + 1} "
+            f"is off air")
+    # Read after the wait: a reconnect REPLACES mixerstate, so a reference
+    # taken before it would be the old, empty dict.
     mixerstate = protocol.mixerstate
     mps = mixerstate.get('mediaplayer-selected') or {}
     if not isinstance(mps, dict):
@@ -250,15 +319,22 @@ def _wait_for_safe_upload_window(protocol, slot_0_indexed: int,
     """Cycle-wait for tally safety before overwriting a media-pool slot. Thin
     wrapper over the shared ``wait_for_safe_cycle`` (content_change.tally) with
     the media-pool slot liveness predicate, so the cold->hot->cold loop is
-    identical to the HyperDeck path."""
+    identical to the HyperDeck path. ``_StateNotReady`` from the predicate is
+    not caught here: it ends the cycle at once, a refusal rather than a wait
+    that runs out the tally timeout as if the slot had stayed live."""
     slot_user = slot_0_indexed + 1
-    tally_present = isinstance(
-        getattr(protocol.mixerstate.get('tally-source'), 'tally', None), dict)
-    log_append(f"slot {slot_user}: tally source "
-               f"{'present (authoritative)' if tally_present else 'ABSENT — using ME1 fallback'}")
+    if not _state_ready(protocol):
+        source = (f"not ready (session reconnecting), waiting up to "
+                  f"{STATE_READY_TIMEOUT:.0f}s for the switcher's state")
+    elif isinstance(getattr(protocol.mixerstate.get('tally-source'), 'tally', None), dict):
+        source = 'present (authoritative)'
+    else:
+        source = 'ABSENT — using ME1 fallback'
+    log_append(f"slot {slot_user}: tally source {source}")
     return wait_for_safe_cycle(
         protocol,
-        is_live=lambda: not _is_slot_safe(protocol, slot_0_indexed),
+        is_live=lambda: not _is_slot_safe(protocol, slot_0_indexed,
+                                          is_cancelled=canceller.is_set),
         is_cancelled=canceller.is_set,
         log=log_append,
         label=f'slot {slot_user}',
@@ -339,9 +415,19 @@ def _upload_one(protocol, slot: int, image_path: str, width: int, height: int,
         if canceller.is_set():
             return ItemResult(slot=slot, image_path=image_path, success=False,
                               error="cancelled before tally check")
-        if not _wait_for_safe_upload_window(protocol, slot, canceller, log_append):
-            err = ("cancelled during tally wait" if canceller.is_set()
-                   else f"tally timeout: slot {slot_user} stayed live > {TALLY_TIMEOUT:.0f}s")
+        not_ready = None
+        try:
+            safe = _wait_for_safe_upload_window(protocol, slot, canceller, log_append)
+        except _StateNotReady as e:
+            safe, not_ready = False, str(e)
+        if not safe:
+            if canceller.is_set():
+                err = "cancelled during tally wait"
+            elif not_ready:
+                err = not_ready
+                log_append(f"slot {slot_user}: FAIL — {err}")
+            else:
+                err = f"tally timeout: slot {slot_user} stayed live > {TALLY_TIMEOUT:.0f}s"
             return ItemResult(slot=slot, image_path=image_path, success=False, error=err)
 
     if canceller.is_set():

{webatem-2.0.2 → webatem-2.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "webatem"
-version = "2.0.2"
+version = "2.0.4"
 description = "Browser-based control for Blackmagic ATEM switchers: run it, open the browser, your switchers are there"
 readme = "README.md"
 license = { text = "MIT" }

{webatem-2.0.2 → webatem-2.0.4}/webatem.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webatem
-Version: 2.0.2
+Version: 2.0.4
 Summary: Browser-based control for Blackmagic ATEM switchers: run it, open the browser, your switchers are there
 Author: Lucas Romanenko
 License: MIT