webatem 2.0.3__tar.gz → 2.0.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webatem
-Version: 2.0.3
+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.3 → 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.3 → webatem-2.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "webatem"
-version = "2.0.3"
+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.3 → webatem-2.0.4}/webatem.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webatem
-Version: 2.0.3
+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