bmdwire 1.5.0__tar.gz → 1.5.1__tar.gz

{bmdwire-1.5.0/bmdwire.egg-info → bmdwire-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmdwire
-Version: 1.5.0
+Version: 1.5.1
 Summary: Python libraries for Blackmagic Design broadcast devices: ATEM switchers, HyperDeck recorders, Ultimatte keyers and Videohub routers
 Author: Lucas Romanenko, Martijn Braam and the OpenAtem contributors
 License-Expression: LGPL-3.0-only AND MIT
@@ -49,7 +49,7 @@ pip install bmdwire
 | **`ultimattewire`** | Ultimatte 12 keyers: archive and restore over the native TCP protocol, Smart Remote 4 compatible zips | MIT | [ultimattewire/README.md](ultimattewire/README.md) |
 | **`videohubwire`** | Videohub routers: state snapshot, crosspoint routing, labels over TCP 9990 | MIT | [videohubwire/README.md](videohubwire/README.md) |
 
-All four are pure standard library except atemwire, whose small C extension ships prebuilt for Linux, macOS and Windows on CPython 3.10 to 3.14, so installing needs no compiler. Pin the version in a requirements file (`bmdwire==1.5.0`) so a later release cannot change your install under you.
+All four are pure standard library except atemwire, whose small C extension ships prebuilt for Linux, macOS and Windows on CPython 3.10 to 3.14, so installing needs no compiler. Pin the version in a requirements file (`bmdwire==1.5.1`) so a later release cannot change your install under you.
 
 ## atemwire stands on pyatem
 

{bmdwire-1.5.0 → bmdwire-1.5.1}/README.md

@@ -15,7 +15,7 @@ pip install bmdwire
 | **`ultimattewire`** | Ultimatte 12 keyers: archive and restore over the native TCP protocol, Smart Remote 4 compatible zips | MIT | [ultimattewire/README.md](ultimattewire/README.md) |
 | **`videohubwire`** | Videohub routers: state snapshot, crosspoint routing, labels over TCP 9990 | MIT | [videohubwire/README.md](videohubwire/README.md) |
 
-All four are pure standard library except atemwire, whose small C extension ships prebuilt for Linux, macOS and Windows on CPython 3.10 to 3.14, so installing needs no compiler. Pin the version in a requirements file (`bmdwire==1.5.0`) so a later release cannot change your install under you.
+All four are pure standard library except atemwire, whose small C extension ships prebuilt for Linux, macOS and Windows on CPython 3.10 to 3.14, so installing needs no compiler. Pin the version in a requirements file (`bmdwire==1.5.1`) so a later release cannot change your install under you.
 
 ## atemwire stands on pyatem
 

{bmdwire-1.5.0 → bmdwire-1.5.1}/atemwire/docs/MEDIA_LOCK.md

@@ -26,6 +26,15 @@ one) did not hold on this hardware.
   on `LKOB`, not only on the release broadcast.
 * A `LOCK` (full store) or `PLCK` sent by a session that **already holds**
   the store gets no answer.
+* A `LOCK` sent while another session holds the store is **queued** too,
+  like a `PLCK` (ATEM Software Control's, 2026-10-15; this package's
+  comments used to say it was dropped). Handed the store at the holder's
+  release, the requester gets `LKOB` and **nothing is announced**, no
+  `LKST` either way.
+* A `PLCK` is granted beside another session's `LOCK`, even half a second
+  into its turn; the `FTSU` that follows aborts the other's transfer in
+  progress with `FTDE 6` (see "Sharing the store with ATEM Software
+  Control").
 * A `LOCK state=0` from a session that does not hold the store does
   nothing visible (this was tested only while a foreign client held it).
 
@@ -180,5 +189,47 @@ holder, which the switcher ignores (see "Requests and grants"). Waiting
 for the echo hid it, at a frame per transfer at best and up to 6.6 s
 measured, during a 20-still restore by bmdctl, which mirrors this code.
 Since `bd6ae77` atemwire holds the lock from `LKOB` to its own release, as
-ASC does, and sends the release and the next request in one packet.
+ASC does. That commit also sent the release and the next request in one
+packet, as ASC does; that shut ASC out, and since `5827626` the next
+request waits its turn (below).
+
+## Sharing the store with ATEM Software Control
+
+Three tests on 2026-10-15, ATEM Software Control connecting to the same
+switcher while a client of this package downloaded stills back to back,
+two of them captured on the ASC machine.
+
+* When it connects, ASC fetches every used still for its thumbnails, one
+  at a time, each under a whole-store `LOCK`. A `LOCK` sent while the
+  other client held the store was queued and handed to ASC at that
+  client's release, with `LKOB` and no `LKST`.
+* With 1.5.0 the other client then asked again at once (its release and
+  next request in one packet), or within half a second: its `PLCK` was
+  granted beside ASC's `LOCK`, and its `FTSU` aborted ASC's download in
+  progress, 230 to 500 ms in, with `FTDE 6`.
+* ASC reacts to the 6 as the notes above say a client should: it
+  releases and asks again in one packet, is queued, and is handed the
+  store at the next release, to be aborted again. **But it tries each
+  still once**: after the 6 it moves on to the next. After 20 stills and
+  20 `FTDE 6` it released the store and asked for nothing more, its
+  thumbnails left empty. It fetched them again only when the media pool
+  changed (a still cleared from another client).
+* Between its own stills ASC releases and asks again in one packet; the
+  switcher announces that as a release and a lock, often in one packet.
+* What lets ASC have its turn (`5827626`): after a release with more
+  work queued, ask again only once the store is announced free, and a
+  frame later (`LOCK_COURTESY`, 60 ms), so a lock announced right behind
+  the release (another client's next transfer) cancels the request;
+  never ask while another client is seen holding the store; and with no
+  announcement at all (the store handed to a waiting request), wait as
+  long as anyone is seen at work, another session's `FTDC` or any `LKST`,
+  asking after `LOCK_QUIET` (10 s) of quiet. With it ASC loaded all 20
+  thumbnails while the other client downloaded; the download paused 38 s
+  for ASC's 20 and went on. Alone, 20 uploads take 14.2 s, against
+  12.7 s with 1.5.0 and about 12 s for ASC.
+* atemwire 1.4.0 waited for its own release's `LKST` echo before asking
+  again, so it waited out a client handed the store too, by accident.
+  bmdctl, which mirrors this code, saw that as unexplained pauses of 2 to
+  6.6 s between stills in a restore: WebATEM, open on the same switcher,
+  was downloading each newly uploaded still for its thumbnail.
 

{bmdwire-1.5.0 → bmdwire-1.5.1}/atemwire/docs/SURFACE.md

@@ -500,7 +500,9 @@ in the transfer flow. At field level, the `CKDV`/`CTDv` fields are all echoed, b
   repeated within 1.0 s (`LOCK_REREQUEST_SECONDS`). There is no timer-driven retry: a dropped
   request is re-sent only on the next event. Since `bd6ae77` the release and the next request go
   in one packet, as ATEM Software Control sends them, and a release broadcast while the store is
-  held changes nothing; after an FTDE 6 the release goes alone (§5.4 item 21).
+  held changes nothing; after an FTDE 6 the release goes alone (§5.4 item 21). Since `5827626`
+  the release goes alone and the next request waits for the store to be announced free and a
+  frame more, never while another client holds it (§5.4 item 26).
 - **`FTDE` status handling:**
   - 1 (try again): re-send the request with the same tid.
   - 5 (no lock): re-request the lock.
@@ -915,7 +917,8 @@ Items 1, 2 and 4 were fixed after 1.2.0, in the commits named in each; they stil
 1.2.0 and earlier, including the 1.1.0 that WebATEM pins. The fly-key bullets of items 9 and
 10, the split-mono bullet of item 8, the float and `sourceId` bullets of item 9, items 15, 16,
 18, 19 and 20, and part of item 17 were fixed after 1.3.0 and still apply to it. Items 21 to 25
-were fixed after 1.4.0 and still apply to it.
+were fixed after 1.4.0 and still apply to it. Item 26 was fixed after 1.5.0 and still applies to
+it.
 
 1. **Profile video mode does not round-trip at fractional rates** (1.2.0). Save writes
    `get_label()` (`1080p59.94`); apply only knows `1080p5994`-style names, so it skips the mode as
@@ -1076,6 +1079,16 @@ were fixed after 1.4.0 and still apply to it.
     the switcher sees no gap, and an upload loses a chunk without a word. *Fixed in `bd6ae77`:*
     `ENOBUFS` and `EAGAIN` are retried for up to 20 ms, and a reliable packet still refused keeps
     its number and its copy for retransmission.
+26. **Another client's turn is cut short** (1.5.0). The release and the next lock request go in
+    one packet (item 21). Another client's request waiting for the store is handed it at the
+    release, unannounced; the next request is granted beside it (a `PLCK` beside a `LOCK`) and
+    its transfer aborts theirs with `FTDE 6`. ATEM Software Control, which tries each still once
+    when it connects, is left without its thumbnails (`docs/MEDIA_LOCK.md`, "Sharing the store
+    with ATEM Software Control"). *Fixed in `5827626`:* the release goes alone; the next request
+    waits for the store to be announced free (`LKST`) and `LOCK_COURTESY` (60 ms) more, never
+    while another client is seen holding the store, and with no announcement waits while anyone
+    is seen at work, asking after `LOCK_QUIET` (10 s) of quiet. `UdpProtocol.wake_at` wakes the
+    protocol for it.
 
 ## Counts
 

{bmdwire-1.5.0 → bmdwire-1.5.1}/atemwire/protocol.py

@@ -33,10 +33,34 @@ def _is_tcp_transport(transport) -> bool:
 
 # A lock request (LOCK / PLCK) with no LKOB back after this long is sent
 # again on the next trigger. Measured: a granted request answers in ~1 ms;
-# a queued PLCK answers the moment the holder releases; a full LOCK sent
-# while another session holds the store is simply dropped by the switcher.
+# a queued one (PLCK, and a full LOCK too: ATEM Software Control's, in a
+# capture of 2026-10-15) the moment the holder releases.
 LOCK_REREQUEST_SECONDS = 1.0
 
+# Another client's turn. A request of another client's that waited for
+# the store is granted the moment we release it, and the switcher grants a
+# request of ours sent soon after too (two sessions asking within ~150 ms
+# can both get LKOB; MEDIA_LOCK.md). Our transfer then aborts theirs with
+# FTDE 6, and ATEM Software Control, which tries each still once when it
+# connects and again only when the media pool changes, is left without
+# its thumbnails (a capture, 2026-10-15: 20 stills, 20 FTDE 6, while a
+# client of this package downloaded back to back; 1.5.0 sent the release
+# and the next request in one packet). A request handed the store at our
+# release isn't announced at all (no LKST either way), and a PLCK of ours
+# is granted beside another client's LOCK even half a second into its
+# turn, its transfer aborted (a second capture, the same day). So after a
+# per-frame release with more work queued for the store, the next request
+# waits for the store to be announced free (LKST), then LOCK_COURTESY more
+# (a frame, for anyone else to take it); a store another client is seen
+# holding (its LKST) is not asked for until announced free. No
+# announcement means someone was handed the store: we wait, as long as
+# anyone is seen at work (another session's FTDC, any LKST), and ask only
+# after LOCK_QUIET with no sign of anyone. bmdwire 1.4.0 waited the same
+# way for the release's echo, by accident: its long waits in a restore
+# were WebATEM refreshing each new still's thumbnail.
+LOCK_COURTESY = 0.06
+LOCK_QUIET = 10.0
+
 # A state dump that ends (InCm) without a video mode has lost its first
 # packet for good: the transport takes the first reliable packet that
 # arrives as the session's baseline, so one lost before it is never resent
@@ -174,6 +198,13 @@ class AtemProtocol:
         # Cleared by the LKOB, by the store's LKST release broadcast (the
         # pounce re-requests anyway), and by every lane reset.
         self._lock_requested = {}
+        # store -> [since, announced]: for a store we released and have more
+        # work for (LOCK_COURTESY), when we released it or last saw anyone
+        # at work, and when it was announced free (None until it is).
+        self._yielding = {}
+        # Stores another client holds, from its LKST until its release's:
+        # we don't ask for them meanwhile (LOCK_COURTESY).
+        self._foreign_held = set()
         self.mode = None
         self.transfer_queue = {}
         self.transfer_id = 42
@@ -221,7 +252,9 @@ class AtemProtocol:
         if isinstance(packet, Wakeup):
             # Caller-side wake-up to drain a pending outbound command — the
             # worker thread (ATEMConnection._run) will pick up the queue
-            # right after this returns. No state to mutate here.
+            # right after this returns — or the transport's, for the lock
+            # yield (wake_at): a store left free may be asked for now.
+            self._service_yields()
             return
         self.connected = True
         if isinstance(packet, TransferQueueFlushed):
@@ -336,8 +369,13 @@ class AtemProtocol:
             # and silent, so mixerstate['lock-state'] only ever showed the
             # last release (bmdwire#15). The packet doesn't name the holder:
             # held by someone else is state=True while self.locks.get(store)
-            # is falsy.
-            pass
+            # is falsy. Held by someone else, we don't ask for it until they
+            # release it (LOCK_COURTESY), and a store we were leaving free
+            # is theirs now.
+            if not self.locks.get(contents.store):
+                self._foreign_held.add(contents.store)
+                if contents.store in self._yielding:
+                    self._yielding[contents.store] = [time.monotonic(), None]
         elif key == 'lock-state' and self.locks.get(contents.store):
             # A release broadcast while we hold the store is the late echo
             # of our own previous release: the switcher announces lock
@@ -349,6 +387,22 @@ class AtemProtocol:
                            f'our own earlier release, announced late')
         elif key == 'lock-state':
             self.log.debug(contents)
+            self._foreign_held.discard(contents.store)
+            # A release announced, ours or another client's: the store is
+            # seen free, and a request waits LOCK_COURTESY more for anyone
+            # else to take it. Another client releasing and taking the store
+            # again for its next transfer (ASC does, in one packet) is
+            # announced as a release then a lock, often in one packet: a
+            # request sent on the release would be granted alongside theirs
+            # and abort their transfer (TEST ATEM 2, 2026-10-15).
+            y = self._yielding.get(contents.store)
+            now = time.monotonic()
+            if y is None and self.transfer_queue.get(contents.store) and self._can_wake():
+                self._yielding[contents.store] = [now, now]
+                self._wake_at(now + LOCK_COURTESY)
+            elif y is not None and y[1] is None:
+                y[1] = now
+                self._wake_at(now + LOCK_COURTESY)
             # The lock is free: whatever request we had outstanding is
             # either about to be granted (a queued PLCK — the switcher
             # grants it directly, sometimes without even broadcasting the
@@ -491,8 +545,10 @@ class AtemProtocol:
                 # this is another session's transfer (watcher, uploader, a
                 # sibling operator) finishing. Expected on a shared setup.
                 self.log.debug("FTDC for another session's transfer — ignoring")
+                self._someone_at_work()
                 return
             if contents.transfer != self.transfer.tid:
+                self._someone_at_work()
                 return
             # Remove current item from the transfer queue
             store = self.transfer.store
@@ -649,6 +705,8 @@ class AtemProtocol:
         self.transfer_buffer_bytes = 0
         self.locks = {}
         self._lock_requested.clear()
+        self._yielding.clear()
+        self._foreign_held.clear()
 
     def release_locks_now(self):
         """Give back every store lock we hold, SYNCHRONOUSLY, for teardown.
@@ -686,6 +744,7 @@ class AtemProtocol:
                                exc_info=True)
             self.locks[store] = False
         self._lock_requested.clear()
+        self._yielding.clear()
 
     def abort_transfers(self):
         """Best-effort reset of the transfer state machine, for callers that
@@ -700,9 +759,11 @@ class AtemProtocol:
         self.transfer_requested = False
         self.transfer_buffer = []
         self.transfer_buffer_bytes = 0
-        # A lock request in flight must not outlive the abort: the queue it
-        # was for is gone, and the next caller's request must not wait on it.
+        # A lock request in flight, or a store left free, must not outlive
+        # the abort: the queue it was for is gone, and the next caller's
+        # request must not wait on it.
         self._lock_requested.clear()
+        self._yielding.clear()
         for lock in list(self.locks):
             if self.locks[lock]:
                 try:
@@ -872,13 +933,11 @@ class AtemProtocol:
         LOCKED and its preview fetches starve (observed live 2026-07-07 on a
         freshly rebooted switcher). ASC holds per frame; now so do we.
 
-        The release and the next transfer's lock request go out in ONE
-        packet, as ATEM Software Control sends them between the stills of a
-        restore and the frames of a download (captures, 2026-10-14 and
-        2026-10-15): the switcher processes the release, then grants the
-        request in under a millisecond, with no wait for the release's LKST
-        echo, which arrives a frame later. The request is the switcher's
-        to queue if another client asked first, as a PLCK is queued.
+        With more work queued for the store, its next lock request waits
+        for the store's next LKST (see LOCK_COURTESY): another client that
+        was waiting gets the store at our release, and a request of ours
+        soon after would abort its transfer. 1.5.0 sent the release and the
+        next request in one packet, as ASC sends them; that shut ASC out.
         ``request_next=False`` sends the release alone and leaves the next
         request to the store's release broadcast (the pounce): after an
         FTDE 6 another session is queued for the store, and asking again
@@ -892,35 +951,49 @@ class AtemProtocol:
         if store != 0xffff and self.locks.get(store):
             self.log.info(f'Releasing lock {store} (per-frame)')
             self.locks[store] = False
-            release = LockCommand(store, False)
+            try:
+                self.send_commands([LockCommand(store, False)])
+            except Exception:
+                self.log.exception('per-frame unlock send failed')
             if not request_next:
-                try:
-                    self.send_commands([release])
-                except Exception:
-                    self.log.exception('per-frame unlock send failed')
                 return  # the store's release broadcast continues the queue
-            self._transfer_trigger(store, release=release)
-            return
+            if self.transfer_queue.get(store) and self._can_wake():
+                # The trigger below defers the request and asks to be woken.
+                self._yielding[store] = [time.monotonic(), None]
         self._transfer_trigger(store)
 
-    def _transfer_trigger(self, store, retry=False, release=None):
-        # ``release``, a per-frame unlock (_release_then_continue), goes in
-        # the same packet as whatever this sends next: the next lock
-        # request, the other releases, or alone if nothing follows.
-        pending = [release] if release is not None else []
-
-        def send(commands):
-            nonlocal pending
-            self.send_commands(pending + list(commands))
-            pending = []
-
-        try:
-            self._transfer_trigger_inner(store, retry, send)
-        finally:
-            if pending:
-                self.send_commands(pending)
-
-    def _transfer_trigger_inner(self, store, retry, send):
+    def _can_wake(self):
+        return hasattr(self.transport, 'wake_at')
+
+    def _wake_at(self, when):
+        wake = getattr(self.transport, 'wake_at', None)
+        if wake is not None:
+            wake(when)
+
+    def _yield_due(self, store):
+        """When a store we are leaving free may be asked for again."""
+        since, announced = self._yielding[store]
+        if announced is not None:
+            return announced + LOCK_COURTESY
+        return since + LOCK_QUIET
+
+    def _someone_at_work(self):
+        """Another session's transfer ended: a store we wait for, not yet
+        announced free, is busy, and LOCK_QUIET starts again."""
+        now = time.monotonic()
+        for y in self._yielding.values():
+            if y[1] is None:
+                y[0] = now
+
+    def _service_yields(self):
+        """Ask for each store we left free whose yield is over."""
+        for store in list(self._yielding):
+            if not self.transfer_queue.get(store):
+                del self._yielding[store]
+            elif not self.transfer_requested and not self.locks.get(store):
+                self._transfer_trigger(store)
+
+    def _transfer_trigger(self, store, retry=False):
         next = None
 
         self.log.info(f'transfer trigger for store {store} (retry={retry})')
@@ -945,11 +1018,24 @@ class AtemProtocol:
                 if self.locks[lock]:
                     self.log.info('Releasing lock {}'.format(lock))
                     cmd = LockCommand(lock, False)
-                    send([cmd])
+                    self.send_commands([cmd])
             return
 
         # Request a lock if needed
         if next.store != 0xffff and (next.store not in self.locks or not self.locks[next.store]):
+            if next.store in self._foreign_held:
+                # Another client's turn: its release's LKST asks for us.
+                self.log.debug(f'Store {next.store} is another client\'s: '
+                               f'asking once they release it')
+                return
+            if next.store in self._yielding:
+                due = self._yield_due(next.store)
+                if time.monotonic() < due:
+                    self.log.debug(f'Leaving store {next.store} free a moment '
+                                   f'for other clients')
+                    self._wake_at(due)
+                    return
+                del self._yielding[next.store]
             asked = self._lock_requested.get(next.store)
             if asked is not None and time.monotonic() - asked < LOCK_REREQUEST_SECONDS:
                 self.log.debug(
@@ -966,7 +1052,7 @@ class AtemProtocol:
             else:
                 cmd = PartialLockCommand(next.store, next.slot)
             self._lock_requested[next.store] = time.monotonic()
-            send([cmd])
+            self.send_commands([cmd])
             return
 
         # A transfer request is already running, don't start a new one
@@ -985,7 +1071,7 @@ class AtemProtocol:
                 self.transfer_queue[next.store] = queue[1:]
             self.log.info(
                 'Clearing {}:{} under store lock'.format(next.store, next.slot))
-            send([ClearStillCommand(slot=next.slot)])
+            self.send_commands([ClearStillCommand(slot=next.slot)])
             self._raise('clear-dispatched', next.store, next.slot)
             self._release_then_continue(next.store)
             return
@@ -1039,4 +1125,4 @@ class AtemProtocol:
                 description=self.transfer.description,
             ))
             self.transfer.metadata_sent = True
-        send(outbound)
+        self.send_commands(outbound)

{bmdwire-1.5.0 → bmdwire-1.5.1}/atemwire/transport.py

@@ -376,6 +376,10 @@ class UdpProtocol(BaseProtocol):
         # when what it hasn't acknowledged is resent (RESEND_AFTER).
         self._acked_through = None
         self._resend_due = None
+        # When receive_packet next returns a Wakeup for the protocol's own
+        # timed work (wake_at); set from the protocol's thread.
+        self._wake_due = None
+        self._wake_lock = threading.Lock()
 
         self.thread_queue = SocketQueue()
         self.thread_recv_queue = Queue()
@@ -478,8 +482,12 @@ class UdpProtocol(BaseProtocol):
                 continue
             if self._resend_due is not None:
                 remaining = max(0.0, min(remaining, self._resend_due - time.monotonic()))
+            wake = self._wake_due
+            if wake is not None:
+                remaining = max(0.0, min(remaining, wake - time.monotonic()))
             readable, _, _ = select.select([self.sock, self.thread_queue], [], [], remaining)
             self._resend_unacked()
+            self._fire_wake()
             for queue in readable:
                 if queue is self.sock:
                     packet = self._receive_packet_low()
@@ -840,6 +848,22 @@ class UdpProtocol(BaseProtocol):
                     raise
                 time.sleep(0.001)
 
+    def wake_at(self, when):
+        """Have receive_packet return a Wakeup at ``when`` (monotonic): the
+        protocol's timed work, which its packets alone can't drive (the
+        switcher's pings never reach it). The earliest of several wins."""
+        with self._wake_lock:
+            if self._wake_due is None or when < self._wake_due:
+                self._wake_due = when
+        self.thread_queue.put(None)              # select() takes the new timeout
+
+    def _fire_wake(self):
+        with self._wake_lock:
+            if self._wake_due is None or time.monotonic() < self._wake_due:
+                return
+            self._wake_due = None
+        self.thread_recv_queue.put(Wakeup())
+
     def _on_ack(self, number):
         """The switcher has our reliable packets through ``number``: the
         resend timer starts again while some remain unacknowledged."""

{bmdwire-1.5.0 → bmdwire-1.5.1/bmdwire.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmdwire
-Version: 1.5.0
+Version: 1.5.1
 Summary: Python libraries for Blackmagic Design broadcast devices: ATEM switchers, HyperDeck recorders, Ultimatte keyers and Videohub routers
 Author: Lucas Romanenko, Martijn Braam and the OpenAtem contributors
 License-Expression: LGPL-3.0-only AND MIT
@@ -49,7 +49,7 @@ pip install bmdwire
 | **`ultimattewire`** | Ultimatte 12 keyers: archive and restore over the native TCP protocol, Smart Remote 4 compatible zips | MIT | [ultimattewire/README.md](ultimattewire/README.md) |
 | **`videohubwire`** | Videohub routers: state snapshot, crosspoint routing, labels over TCP 9990 | MIT | [videohubwire/README.md](videohubwire/README.md) |
 
-All four are pure standard library except atemwire, whose small C extension ships prebuilt for Linux, macOS and Windows on CPython 3.10 to 3.14, so installing needs no compiler. Pin the version in a requirements file (`bmdwire==1.5.0`) so a later release cannot change your install under you.
+All four are pure standard library except atemwire, whose small C extension ships prebuilt for Linux, macOS and Windows on CPython 3.10 to 3.14, so installing needs no compiler. Pin the version in a requirements file (`bmdwire==1.5.1`) so a later release cannot change your install under you.
 
 ## atemwire stands on pyatem
 

{bmdwire-1.5.0 → bmdwire-1.5.1}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bmdwire"
-version = "1.5.0"
+version = "1.5.1"
 description = "Python libraries for Blackmagic Design broadcast devices: ATEM switchers, HyperDeck recorders, Ultimatte keyers and Videohub routers"
 readme = "README.md"
 # atemwire is a fork of pyatem and stays LGPL-3.0-only; the other three were