ultimattewire 0.1.0.dev0__py3-none-any.whl

ultimattewire/__init__.py

@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: MIT
+"""
+ultimattewire — Blackmagic Ultimatte 12 / 12 4K control library.
+
+Protocol layer reverse-engineered from packet captures against real
+hardware; opcodes, frame format, byte order, and sequence must match
+the unit's parser exactly. See ultimattewire.profile for the Smart
+Remote-compatible Archive/Restore feature (the first public
+implementation of it outside BMD's own tools).
+"""
+
+from ultimattewire.profile import archive_unit_to_bytes, restore_unit_from_bytes
+
+__all__ = [
+    "archive_unit_to_bytes",
+    "restore_unit_from_bytes",
+]

ultimattewire/_preamble.py

@@ -0,0 +1,76 @@
+# SPDX-License-Identifier: MIT
+"""
+Ultimatte 9998 text channel: connect, read the prelude, and parse named
+sections out of it. Used by profile/archive (to build the zip) and by
+any future feature that needs the unit's current state (label, video
+mode, FILE LIST, etc.).
+"""
+
+import re
+import socket
+
+from ultimattewire._protocol import CONNECT_TIMEOUT, CONTROL_PORT, _connect_with_retry
+
+
+PREAMBLE_QUIET_TIMEOUT = 2.0
+
+
+def read_preamble(host, connect_timeout=CONNECT_TIMEOUT,
+                  quiet_timeout=PREAMBLE_QUIET_TIMEOUT):
+    """Connect to 9998 and read until 'END PRELUDE:'."""
+    s = _connect_with_retry(host, CONTROL_PORT, timeout=connect_timeout)
+    s.settimeout(quiet_timeout)
+    buf = bytearray()
+    try:
+        while True:
+            try:
+                chunk = s.recv(65536)
+            except socket.timeout:
+                break
+            if not chunk:
+                break
+            buf.extend(chunk)
+            if b"END PRELUDE:" in buf:
+                s.settimeout(0.3)
+                try:
+                    while True:
+                        more = s.recv(65536)
+                        if not more:
+                            break
+                        buf.extend(more)
+                except socket.timeout:
+                    pass
+                break
+    finally:
+        s.close()
+    return buf.decode("utf-8", errors="replace")
+
+
+def parse_section(text, header):
+    """Extract the body of a named CAPS-header section from a prelude."""
+    # NOTE: use \Z (end-of-string only), not $ — with re.MULTILINE, $ matches
+    # at the end of every line, which would terminate the lazy capture after
+    # the first line of the section. This bug caused multi-line FILE LIST
+    # sections (e.g. with multiple presets) to be truncated to just the first
+    # entry.
+    # Also: use [ \t]* (not \s*) after the header colon — \s* matches newlines
+    # too, which would cause an empty section to swallow the next section.
+    pattern = rf"^{re.escape(header)}:[ \t]*\n(.*?)(?=\n[A-Z][A-Z0-9 ]*:\s*\n|\nEND PRELUDE:|\Z)"
+    m = re.search(pattern, text, re.MULTILINE | re.DOTALL)
+    return m.group(1).strip() if m else ""
+
+
+def parse_file_list(text):
+    """Return the list of preset slot names from the FILE LIST section."""
+    section = parse_section(text, "FILE LIST")
+    if not section:
+        return []
+    return [ln.strip() for ln in section.splitlines() if ln.strip()]
+
+
+def extract_label(text):
+    """Return the unit's Label field, sanitized for use as a filename root."""
+    m = re.search(r"^Label:\s*(.+)$", text, re.MULTILINE)
+    if m:
+        return re.sub(r"[^A-Za-z0-9._-]+", "_", m.group(1).strip())
+    return "unknown"

ultimattewire/_protocol.py

@@ -0,0 +1,146 @@
+# SPDX-License-Identifier: MIT
+"""
+Low-level Ultimatte protocol primitives shared by every ultimattewire
+feature: ports, timeouts, and the 9996 binary-channel frame I/O.
+
+Binary-channel frame formats (TCP 9996):
+    Read  : send [opcode:2BE][len:4BE][payload]
+            recv [len:4BE][body]
+    Write : send [opcode:2BE][name_len:4BE][name:N][data_len:4BE][data:M][0x00]
+            recv 6 bytes of zeros = success ACK
+
+The trailing 0x00 on writes and the exact framing are required — the
+unit will not ACK frames that don't match. Do not change these without
+re-validating against hardware.
+"""
+
+import socket
+import struct
+import time
+
+
+CONTROL_PORT = 9998          # text channel (preamble, FILE LIST, etc.)
+SETTINGS_PORT = 9996         # binary channel (read/write slot blobs + resources)
+CONNECT_TIMEOUT = 5.0
+READ_TIMEOUT = 30.0
+ACK_LEN = 6                  # write-ack: 6 zero bytes
+_CONNECT_RETRY_DELAY = 0.25  # seconds between connect attempts
+
+
+def _recv_exact(sock, n):
+    """Read exactly n bytes from sock, or short-read on EOF."""
+    buf = b""
+    while len(buf) < n:
+        chunk = sock.recv(n - len(buf))
+        if not chunk:
+            break
+        buf += chunk
+    return buf
+
+
+def _connect_with_retry(host, port, timeout=CONNECT_TIMEOUT):
+    """Open a TCP connection to (host, port) with one retry on transient
+    failure. Retries cover only the connect phase — once a socket is
+    returned, data-side errors are real failures and not retried.
+
+    Defeats cold-ARP and first-packet hiccups that present as connection
+    refused / OSError / timeout on the first attempt and resolve on the
+    second a few hundred ms later.
+    """
+    last_error = None
+    for attempt in range(2):
+        try:
+            return socket.create_connection((host, port), timeout=timeout)
+        except (ConnectionRefusedError, socket.timeout, OSError) as e:
+            last_error = e
+            if attempt == 0:
+                time.sleep(_CONNECT_RETRY_DELAY)
+    raise last_error
+
+
+def binary_request(host, opcode, payload, timeout=CONNECT_TIMEOUT):
+    """Issue a binary read on 9996 and return the body bytes (may be empty).
+
+    Frame: send [opcode:2BE][len:4BE][payload]
+           recv [len:4BE][body]
+
+    A short read of the length header (including a clean immediate EOF;
+    we just sent a request, so a reply is owed) or of the body raises
+    IOError instead of returning empty/truncated bytes (2026-07-06).
+    Before that, a unit that accepted the connection but closed before or
+    mid reply yielded silent empty/truncated resources that the archive
+    path would zip and later RESTORE to live hardware. A genuinely empty resource (header
+    says length 0) still returns b"" cleanly.
+    """
+    if isinstance(payload, str):
+        payload = payload.encode()
+    # Cold-ARP retry like upload_one/read_preamble — the read path was the
+    # one caller still connecting bare, so archive reads sporadically
+    # failed on cold units while writes succeeded.
+    s = _connect_with_retry(host, SETTINGS_PORT, timeout=timeout)
+    s.settimeout(timeout)
+    try:
+        frame = struct.pack(">HI", opcode, len(payload)) + payload
+        s.sendall(frame)
+        length_bytes = _recv_exact(s, 4)
+        if len(length_bytes) < 4:
+            raise IOError(
+                f"short read on length header (got {len(length_bytes)} of 4 "
+                f"bytes; unit closed before replying)"
+            )
+        (length,) = struct.unpack(">I", length_bytes)
+        if not length:
+            return b""
+        body = _recv_exact(s, length)
+        if len(body) != length:
+            raise IOError(
+                f"short read on body (got {len(body)} of {length} bytes)"
+            )
+        return body
+    finally:
+        s.close()
+
+
+def upload_one(host, opcode, name, payload, connect_timeout=CONNECT_TIMEOUT,
+               read_timeout=READ_TIMEOUT):
+    """Issue a binary write on 9996. Raises IOError if the unit rejects.
+
+    Frame: send [opcode:2BE][name_len:4BE][name:N][data_len:4BE][data:M][0x00]
+           recv 6 bytes of zeros = success ACK
+
+    The trailing 0x00 is required — the unit will not ACK without it.
+    """
+    name_bytes = name.encode("utf-8")
+    frame = (
+        struct.pack(">H", opcode)
+        + struct.pack(">I", len(name_bytes))
+        + name_bytes
+        + struct.pack(">I", len(payload))
+        + payload
+        + b"\x00"
+    )
+    s = _connect_with_retry(host, SETTINGS_PORT, timeout=connect_timeout)
+    try:
+        s.settimeout(read_timeout)
+        s.sendall(frame)
+        # The unit sends the ACK then closes the connection quickly, so recv()
+        # can surface EOF before all ACK_LEN bytes arrive depending on TCP
+        # timing. Tolerate short reads as long as we get something that looks
+        # like a success ACK (all zeros).
+        ack = b""
+        while len(ack) < ACK_LEN:
+            try:
+                chunk = s.recv(ACK_LEN - len(ack))
+            except socket.timeout:
+                raise IOError(
+                    f"timeout waiting for ACK (got {len(ack)} of {ACK_LEN} bytes)"
+                )
+            if not chunk:
+                break
+            ack += chunk
+        if len(ack) == 0:
+            raise IOError("connection closed with no ACK bytes (frame rejected)")
+        if any(b != 0 for b in ack):
+            raise IOError(f"non-zero ACK from unit (likely error): {ack.hex()}")
+    finally:
+        s.close()

ultimattewire/profile/__init__.py

@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: MIT
+"""
+ultimattewire.profile — Smart Remote-compatible Archive / Restore.
+
+Parallel to BMD Smart Remote 4's "Archive All" / "Restore" — produces
+and consumes zip files that round-trip through Smart Remote unchanged.
+First public implementation of this feature outside BMD's own tools.
+"""
+
+from ultimattewire.profile.archive import archive_unit_to_bytes
+from ultimattewire.profile.restore import restore_unit_from_bytes
+
+__all__ = [
+    "archive_unit_to_bytes",
+    "restore_unit_from_bytes",
+]

ultimattewire/profile/_ranges.py

@@ -0,0 +1,282 @@
+# SPDX-License-Identifier: MIT
+"""
+Per-parameter display ranges and the annotated-preamble helper. Used by
+profile/archive.py to emit the bonus human-readable .txt dump alongside
+the binary zip. Source: Ultimatte 12 Operations Manual (Feb 2026) +
+Smart Remote 4 panel screenshots.
+"""
+
+
+# Maps protocol parameter name -> (raw_min, raw_max, display_min,
+#                                  display_default, display_max, unit_label).
+# If display_min is None, the value is shown as-is (e.g. pixel counts,
+# frame counts).
+RANGES = {
+    # Matte
+    "Matte Density":                (0, 10000, -100, 0, 300, "%"),
+    "Black Gloss":                  (0, 10000, 0, 0, 100, "%"),
+    "Blue Density":                 (0, 10000, 0, 0, 100, "%"),
+    "Green Density":                (0, 10000, 0, 0, 100, "%"),
+    "Red Density":                  (0, 10000, 0, 0, 100, "%"),
+    "Shadow Level":                 (0, 10000, 0, 0, 100, "%"),
+    "Shadow Threshold":             (0, 10000, 0, 0, 100, "%"),
+    "Matte Correct Horizontal Size": (0, 6, None, None, None, "px"),
+    "Matte Correct Vertical Size":  (0, 3, None, None, None, "lines"),
+
+    # Cursor positions
+    "Cursor X":                     (0, 10000, 0, 0, 100, "%"),
+    "Cursor Y":                     (0, 10000, 0, 0, 100, "%"),
+    "Cursor 2 X":                   (0, 10000, 0, 0, 100, "%"),
+    "Cursor 2 Y":                   (0, 10000, 0, 0, 100, "%"),
+
+    # Veil
+    "Veil Master":                  (0, 10000, 0, 0, 100, "%"),
+    "Veil Red":                     (0, 10000, 0, 0, 100, "%"),
+    "Veil Green":                   (0, 10000, 0, 0, 100, "%"),
+    "Veil Blue":                    (0, 10000, 0, 0, 100, "%"),
+    "Veil Correct Horizontal Size": (0, 6, None, None, None, "px"),
+    "Veil Correct Vertical Size":   (0, 6, None, None, None, "lines"),
+
+    # Wall/floor sample colors
+    "Wall Color Red":               (0, 10000, 0, 0, 100, "%"),
+    "Wall Color Green":             (0, 10000, 0, 0, 100, "%"),
+    "Wall Color Blue":              (0, 10000, 0, 0, 100, "%"),
+    "Floor Color Red":              (0, 10000, 0, 0, 100, "%"),
+    "Floor Color Green":            (0, 10000, 0, 0, 100, "%"),
+    "Floor Color Blue":             (0, 10000, 0, 0, 100, "%"),
+
+    # Clean Up
+    "Cleanup Level":                (0, 10000, 0, 0, 100, "%"),
+    "Cleanup Dark Recover":         (0, 10000, 0, 0, 100, "%"),
+    "Cleanup Light Recover":        (0, 10000, 0, 0, 100, "%"),
+    "Cleanup Strength":             (0, 10000, 0, 0, 100, "%"),
+    "GM Cleanup Level":             (0, 10000, 0, 0, 100, "%"),
+    "GM Cleanup Dark Recover":      (0, 10000, 0, 0, 100, "%"),
+    "GM Cleanup Light Recover":     (0, 10000, 0, 0, 100, "%"),
+    "GM Cleanup Strength":          (0, 10000, 0, 0, 100, "%"),
+
+    # Filter
+    "Correction Level":             (0, 10000, 0, 0, 100, "%"),
+    "Noise Level":                  (0, 10000, 0, 0, 100, "%"),
+
+    # Flare 1 / Flare 2
+    "Black Balance":                (0, 10000, -100, 0, 100, "%"),
+    "Gray Balance":                 (0, 10000, -100, 0, 100, "%"),
+    "White Balance":                (0, 10000, -100, 0, 100, "%"),
+    "Flare Level":                  (0, 10000, 0, 0, 100, "%"),
+    "Cool":                         (0, 10000, 0, 0, 100, "%"),
+    "Skin Tone":                    (0, 10000, 0, 0, 100, "%"),
+    "Light Warm":                   (0, 10000, 0, 0, 100, "%"),
+    "Dark Warm":                    (0, 10000, 0, 0, 100, "%"),
+    "Flare Correct Horizontal Size": (0, 6, None, None, None, "px"),
+    "Flare Correct Vertical Size":  (0, 6, None, None, None, "lines"),
+
+    # Ambiance
+    "Ambiance Master":              (0, 10000, 0, 0, 100, "%"),
+    "Ambiance Red":                 (0, 10000, 0, 0, 100, "%"),
+    "Ambiance Green":               (0, 10000, 0, 0, 100, "%"),
+    "Ambiance Blue":                (0, 10000, 0, 0, 100, "%"),
+    "Ambiance Strength":            (0, 10000, 0, 0, 100, "%"),
+    "Direct Light Red":             (0, 10000, 0, 0, 100, "%"),
+    "Direct Light Green":           (0, 10000, 0, 0, 100, "%"),
+    "Direct Light Blue":            (0, 10000, 0, 0, 100, "%"),
+    "Direct Light Mix":             (0, 10000, 0, 0, 100, "%"),
+    "Vertical Blur":                (0, 10000, 0, 0, 100, "%"),
+
+    # Foreground color
+    "FG Saturation Red":            (0, 10000, 0, 100, 200, "%"),
+    "FG Saturation Green":          (0, 10000, 0, 100, 200, "%"),
+    "FG Saturation Blue":           (0, 10000, 0, 100, 200, "%"),
+    "FG Saturation Master":         (0, 10000, 0, 100, 200, "%"),
+    "FG Contrast Red":              (0, 10000, 0, 100, 200, "%"),
+    "FG Contrast Green":            (0, 10000, 0, 100, 200, "%"),
+    "FG Contrast Blue":             (0, 10000, 0, 100, 200, "%"),
+    "FG Contrast Master":           (0, 10000, 0, 100, 200, "%"),
+    "FG Black Red":                 (0, 10000, -100, 0, 100, "%"),
+    "FG Black Green":               (0, 10000, -100, 0, 100, "%"),
+    "FG Black Blue":                (0, 10000, -100, 0, 100, "%"),
+    "FG Black Master":              (0, 10000, -100, 0, 100, "%"),
+    "FG White Red":                 (0, 10000, 0, 100, 200, "%"),
+    "FG White Green":               (0, 10000, 0, 100, 200, "%"),
+    "FG White Blue":                (0, 10000, 0, 100, 200, "%"),
+    "FG White Master":              (0, 10000, 0, 100, 200, "%"),
+    "FG Contrast Crossover":        (0, 10000, 0, 50, 100, "%"),
+    "Fade Mix":                     (0, 10000, 0, 100, 100, "%"),
+
+    # Background color
+    "BG Saturation Red":            (0, 10000, 0, 100, 200, "%"),
+    "BG Saturation Green":          (0, 10000, 0, 100, 200, "%"),
+    "BG Saturation Blue":           (0, 10000, 0, 100, 200, "%"),
+    "BG Saturation Master":         (0, 10000, 0, 100, 200, "%"),
+    "BG Contrast Red":              (0, 10000, 0, 100, 200, "%"),
+    "BG Contrast Green":            (0, 10000, 0, 100, 200, "%"),
+    "BG Contrast Blue":             (0, 10000, 0, 100, 200, "%"),
+    "BG Contrast Master":           (0, 10000, 0, 100, 200, "%"),
+    "BG Black Red":                 (0, 10000, -100, 0, 100, "%"),
+    "BG Black Green":               (0, 10000, -100, 0, 100, "%"),
+    "BG Black Blue":                (0, 10000, -100, 0, 100, "%"),
+    "BG Black Master":              (0, 10000, -100, 0, 100, "%"),
+    "BG White Red":                 (0, 10000, 0, 100, 200, "%"),
+    "BG White Green":               (0, 10000, 0, 100, 200, "%"),
+    "BG White Blue":                (0, 10000, 0, 100, 200, "%"),
+    "BG White Master":              (0, 10000, 0, 100, 200, "%"),
+    "BG Contrast Crossover":        (0, 10000, 0, 50, 100, "%"),
+    "BG Filter":                    (0, 10000, 0, 0, 100, "%"),
+    "Test Signal Master":           (0, 10000, 0, 0, 100, "%"),
+    "Test Signal Red":              (0, 10000, 0, 0, 100, "%"),
+    "Test Signal Green":            (0, 10000, 0, 0, 100, "%"),
+    "Test Signal Blue":             (0, 10000, 0, 0, 100, "%"),
+
+    # Layer color
+    "LY Saturation Red":            (0, 10000, 0, 100, 200, "%"),
+    "LY Saturation Green":          (0, 10000, 0, 100, 200, "%"),
+    "LY Saturation Blue":           (0, 10000, 0, 100, 200, "%"),
+    "LY Saturation Master":         (0, 10000, 0, 100, 200, "%"),
+    "LY Contrast Red":              (0, 10000, 0, 100, 200, "%"),
+    "LY Contrast Green":            (0, 10000, 0, 100, 200, "%"),
+    "LY Contrast Blue":             (0, 10000, 0, 100, 200, "%"),
+    "LY Contrast Master":           (0, 10000, 0, 100, 200, "%"),
+    "LY Black Red":                 (0, 10000, -100, 0, 100, "%"),
+    "LY Black Green":               (0, 10000, -100, 0, 100, "%"),
+    "LY Black Blue":                (0, 10000, -100, 0, 100, "%"),
+    "LY Black Master":              (0, 10000, -100, 0, 100, "%"),
+    "LY White Red":                 (0, 10000, 0, 100, 200, "%"),
+    "LY White Green":               (0, 10000, 0, 100, 200, "%"),
+    "LY White Blue":                (0, 10000, 0, 100, 200, "%"),
+    "LY White Master":              (0, 10000, 0, 100, 200, "%"),
+    "LY Contrast Crossover":        (0, 10000, 0, 50, 100, "%"),
+    "LY Filter":                    (0, 10000, 0, 0, 100, "%"),
+    "LY Test Signal Master":        (0, 10000, 0, 0, 100, "%"),
+    "LY Test Signal Red":           (0, 10000, 0, 0, 100, "%"),
+    "LY Test Signal Green":         (0, 10000, 0, 0, 100, "%"),
+    "LY Test Signal Blue":          (0, 10000, 0, 0, 100, "%"),
+    "LY Fade Mix":                  (0, 10000, 0, 100, 100, "%"),
+
+    # Lighting
+    "Lighting Level Red":           (0, 10000, 0, 100, 200, "%"),
+    "Lighting Level Green":         (0, 10000, 0, 100, 200, "%"),
+    "Lighting Level Blue":          (0, 10000, 0, 100, 200, "%"),
+    "Lighting Level Master":        (0, 10000, 0, 100, 200, "%"),
+    "Lighting Minimum Level":       (0, 10000, 0, 25, 100, "%"),
+
+    # Window
+    "Window Position Top":          (0, 10000, 0, 0, 100, "%"),
+    "Window Position Bottom":       (0, 10000, 0, 0, 100, "%"),
+    "Window Position Left":         (0, 10000, 0, 0, 100, "%"),
+    "Window Position Right":        (0, 10000, 0, 0, 100, "%"),
+    "Window Softness Top":          (0, 10000, 0, 0, 100, "%"),
+    "Window Softness Bottom":       (0, 10000, 0, 0, 100, "%"),
+    "Window Softness Left":         (0, 10000, 0, 0, 100, "%"),
+    "Window Softness Right":        (0, 10000, 0, 0, 100, "%"),
+    "Window Skew Top":              (0, 10000, 0, 0, 100, "%"),
+    "Window Skew Bottom":           (0, 10000, 0, 0, 100, "%"),
+    "Window Skew Left":             (0, 10000, 0, 0, 100, "%"),
+    "Window Skew Right":            (0, 10000, 0, 0, 100, "%"),
+    "Window Skew Offset Top":       (0, 10000, 0, 0, 100, "%"),
+    "Window Skew Offset Bottom":    (0, 10000, 0, 0, 100, "%"),
+    "Window Skew Offset Left":     (0, 10000, 0, 0, 100, "%"),
+    "Window Skew Offset Right":    (0, 10000, 0, 0, 100, "%"),
+
+    # Transition rate
+    "Transition Rate":              (1, 120, None, None, None, "frames"),
+
+    # Matte Input processing
+    "BM Process Horizontal":        (0, 3, None, None, None, "px"),
+    "BM Process Vertical":          (0, 3, None, None, None, "lines"),
+    "BM Filter":                    (0, 10000, 0, 0, 100, "%"),
+    "BM Input Level":               (0, 10000, 0, 100, 200, "%"),
+    "BM Input Offset":              (0, 10000, -100, 0, 100, "%"),
+    "GM Process Horizontal":        (0, 3, None, None, None, "px"),
+    "GM Process Vertical":          (0, 3, None, None, None, "lines"),
+    "GM Filter":                    (0, 10000, 0, 0, 100, "%"),
+    "GM Input Level":               (0, 10000, 0, 100, 200, "%"),
+    "GM Input Offset":              (0, 10000, -100, 0, 100, "%"),
+    "HM Process Horizontal":        (0, 3, None, None, None, "px"),
+    "HM Process Vertical":          (0, 3, None, None, None, "lines"),
+    "HM Filter":                    (0, 10000, 0, 0, 100, "%"),
+    "HM Input Level":               (0, 10000, 0, 100, 200, "%"),
+    "HM Input Offset":              (0, 10000, -100, 0, 100, "%"),
+    "LM Process Horizontal":        (0, 3, None, None, None, "px"),
+    "LM Process Vertical":          (0, 3, None, None, None, "lines"),
+    "LM Filter":                    (0, 10000, 0, 0, 100, "%"),
+    "LM Input Level":               (0, 10000, 0, 100, 200, "%"),
+    "LM Input Offset":              (0, 10000, -100, 0, 100, "%"),
+
+    # Noise cursor
+    "Noise Cursor X":               (0, 10000, 0, 0, 100, "%"),
+    "Noise Cursor Y":               (0, 10000, 0, 0, 100, "%"),
+
+    # FG input timing
+    "FG Input Frame Delay":         (0, 14, None, None, None, "frames"),
+    "FG Input U Position":          (0, 10000, -2, 0, 2, "px"),
+    "FG Input V Position":          (0, 10000, -2, 0, 2, "px"),
+    "FG Input UV Position":         (0, 10000, -2, 0, 2, "px"),
+
+    # Highlight levels
+    "Talent Highlight Level":       (0, 10000, 0, 0, 100, "%"),
+    "Monitor Highlight Level":      (0, 10000, 0, 0, 100, "%"),
+
+    # Matte output level
+    "Matte Out Level":              (0, 10000, 0, 100, 100, "%"),
+
+    # Output offset
+    "Output Offset":                (-1500, 1500, None, None, None, "subpx"),
+
+    # GPI delays
+    "GP Out Delay":                 (1, 120, None, None, None, "frames"),
+    "GP 1 Input Delay":             (1, 120, None, None, None, "frames"),
+    "GP 2 Input Delay":             (1, 120, None, None, None, "frames"),
+    "GP 3 Input Delay":             (1, 120, None, None, None, "frames"),
+    "GP 4 Input Delay":             (1, 120, None, None, None, "frames"),
+    "GP 5 Input Delay":             (1, 120, None, None, None, "frames"),
+}
+
+
+def to_display(name, raw_value):
+    """Convert raw protocol value to (display_value, unit). Returns
+    (None, None) if the param has no range entry or the value isn't
+    numeric."""
+    if name not in RANGES:
+        return None, None
+    try:
+        raw = float(raw_value)
+    except (TypeError, ValueError):
+        return None, None
+    rmin, rmax, dmin, _ddef, dmax, unit = RANGES[name]
+    if dmin is None:
+        return raw, unit
+    if rmax == rmin:
+        return dmin, unit
+    pct = (raw - rmin) / (rmax - rmin)
+    return dmin + pct * (dmax - dmin), unit
+
+
+def annotate_preamble(preamble):
+    """Walk the preamble line-by-line and append (display) annotations
+    to matched CONTROL lines. Returns the annotated string."""
+    out = []
+    in_control = False
+    for line in preamble.splitlines():
+        stripped = line.rstrip("\r")
+        if stripped.endswith(":") and not stripped.startswith(" "):
+            header = stripped[:-1]
+            in_control = header in ("CONTROL", "CONTROL DEFAULT")
+            out.append(stripped)
+            continue
+        if not in_control or ":" not in stripped:
+            out.append(stripped)
+            continue
+        name, _, value = stripped.partition(":")
+        name = name.strip()
+        value = value.strip()
+        lookup_name = name[7:] if name.startswith("Offset ") else name
+        display, unit = to_display(lookup_name, value)
+        if display is None:
+            out.append(stripped)
+            continue
+        num = str(int(display))
+        sep = "" if unit == "%" else " "
+        annot = f"{num}{sep}{unit}"
+        left = f"{name}: {value}"
+        out.append(f"{left:<40} ({annot})")
+    return "\n".join(out) + "\n"

ultimattewire/profile/archive.py

@@ -0,0 +1,136 @@
+# SPDX-License-Identifier: MIT
+"""
+Ultimatte archive — produces a zip identical to Smart Remote's
+"Archive All".
+
+This module is a port of the standalone archive script that was
+reverse-engineered from packet captures against a real
+Ultimatte 12 4K. Protocol details (opcodes, frame format, zip layout,
+byte order, ranges, sequence) MUST NOT be changed without re-validating
+against hardware — the unit's parser is strict about all of them.
+
+Zip structure (matches Smart Remote so the zip restores from the app):
+    <label>.zip/
+        images/                    (empty unless unit has images)
+        GPISettings                (raw bytes, no length prefix)
+        SavedSettings              (raw bytes, no length prefix)
+        quickfiles/                (empty unless unit has quickfiles)
+        presets/                   (explicit dir entry — Smart Remote requires)
+        presets/<slot_name>        (one file per saved slot from FILE LIST)
+        <label>_config_readable.txt (bonus: human-readable annotated state
+                                    dump. Ignored by Smart Remote on restore.)
+"""
+
+import io
+import zipfile
+from datetime import datetime
+
+from ultimattewire._preamble import (
+    PREAMBLE_QUIET_TIMEOUT,
+    extract_label,
+    parse_file_list,
+    read_preamble,
+)
+from ultimattewire._protocol import CONNECT_TIMEOUT, binary_request
+from ultimattewire.profile._ranges import annotate_preamble
+
+
+OP_READ_SLOT = 0x0000
+OP_READ_RESOURCE = 0x0003
+
+
+def _get_slot_blob(host, slot_name, timeout=CONNECT_TIMEOUT):
+    return binary_request(host, OP_READ_SLOT, slot_name, timeout=timeout)
+
+
+def _get_resource(host, name, timeout=CONNECT_TIMEOUT):
+    return binary_request(host, OP_READ_RESOURCE, name, timeout=timeout)
+
+
+def archive_unit_to_bytes(host, request_timeout=CONNECT_TIMEOUT):
+    """Pull a full archive of one Ultimatte and return (zip_bytes, info).
+
+    info is a dict:
+        {
+            "label": "<unit protocol label, sanitized>",
+            "slots": ["slot1", "slot2", ...],     # slots present in FILE LIST
+            "slot_sizes": {"slot1": int, ...},    # per-slot blob size; absent on per-slot failure
+            "gpi_size": int,                      # 0 if read failed
+            "saved_size": int,                    # 0 if read failed
+            "warnings": ["...", ...],             # per-resource soft failures
+        }
+
+    Raises Exception on hard failures (cannot reach preamble at all).
+    """
+    warnings = []
+
+    preamble = read_preamble(host, connect_timeout=request_timeout,
+                             quiet_timeout=PREAMBLE_QUIET_TIMEOUT)
+    if not preamble:
+        raise IOError("empty preamble (unit unreachable or not responding)")
+
+    label = extract_label(preamble)
+    slots = parse_file_list(preamble)
+
+    slot_blobs = {}
+    slot_sizes = {}
+    for slot in slots:
+        try:
+            blob = _get_slot_blob(host, slot, timeout=request_timeout)
+            slot_blobs[slot] = blob
+            slot_sizes[slot] = len(blob)
+        except Exception as e:
+            warnings.append(f"preset {slot!r}: {e}")
+
+    # If a resource read fails, omit it from the zip rather than embedding
+    # a placeholder — the restore side handles missing resources by
+    # skipping them, but it would faithfully push a placeholder back to
+    # the unit and silently corrupt the live config.
+    gpi_settings = None
+    try:
+        gpi_settings = _get_resource(host, "GPISettings", timeout=request_timeout)
+    except Exception as e:
+        warnings.append(f"GPISettings: {e}")
+
+    saved_settings = None
+    try:
+        saved_settings = _get_resource(host, "SavedSettings", timeout=request_timeout)
+    except Exception as e:
+        warnings.append(f"SavedSettings: {e}")
+
+    readable_text = annotate_preamble(preamble)
+    now = datetime.now().timetuple()[:6]
+
+    def dir_entry(name):
+        zi = zipfile.ZipInfo(name, date_time=now)
+        zi.external_attr = 0o40755 << 16
+        return zi
+
+    # Build the zip in Smart Remote's exact format. Order and the explicit
+    # "presets/" parent directory entry matter — Software Control's parser
+    # rejects archives that don't match this layout.
+    # Smart Remote order: images/, GPISettings, SavedSettings, quickfiles/,
+    #                     presets/, presets/<slot>, presets/<slot>, ...
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr(dir_entry("images/"), "")
+        if gpi_settings is not None:
+            zf.writestr("GPISettings", gpi_settings)
+        if saved_settings is not None:
+            zf.writestr("SavedSettings", saved_settings)
+        zf.writestr(dir_entry("quickfiles/"), "")
+        zf.writestr(dir_entry("presets/"), "")
+        for slot, blob in slot_blobs.items():
+            zf.writestr(f"presets/{slot}", blob)
+        # Bonus: annotated state dump for humans. Smart Remote ignores unknown
+        # entries on restore, so this just rides along inside the archive.
+        zf.writestr(f"{label}_config_readable.txt", readable_text)
+
+    return buf.getvalue(), {
+        "label": label,
+        "slots": slots,
+        "slot_sizes": slot_sizes,
+        "gpi_size": len(gpi_settings) if gpi_settings is not None else 0,
+        "saved_size": len(saved_settings) if saved_settings is not None else 0,
+        "warnings": warnings,
+    }

ultimattewire/profile/restore.py

@@ -0,0 +1,115 @@
+# SPDX-License-Identifier: MIT
+"""
+Ultimatte 12 / 12 4K restore — pushes a Smart Remote-style archive zip
+back to a unit. Replicates the protocol Software Control uses for
+"Restore".
+
+This module is a port of the standalone restore script that was
+reverse-engineered from packet captures against a real
+Ultimatte 12 4K. Protocol details (opcodes, frame format, trailing 0x00
+byte, restore order, 'name' field format) MUST NOT be changed without
+re-validating against hardware — the unit will not ACK frames that
+don't match.
+
+Protocol (TCP 9996, one upload per connection):
+    Request : [opcode:2BE][name_len:4BE][name:N][data_len:4BE][data:M][0x00]
+    Response: 6 bytes of zeros = success ACK
+
+    Opcodes:
+        0x0100  write a preset slot (mirror of read 0x0000)
+        0x0103  write GPISettings or SavedSettings (mirror of read 0x0003)
+
+    Software Control puts the full filesystem path of the extracted zip
+    member into the 'name' field. The unit only cares about the last
+    path segment (and that "presets/" appears for slot writes), so we
+    mimic the Software Control path layout for safety. The trailing
+    0x00 byte is required — the unit will not ACK without it.
+
+Restore order (matches Software Control captures):
+    1. presets/<slot>  for every slot in the zip
+    2. GPISettings
+    3. SavedSettings   (overwrites live state, so save it for last)
+"""
+
+import io
+import zipfile
+
+from ultimattewire._protocol import CONNECT_TIMEOUT, READ_TIMEOUT, upload_one
+
+
+OP_WRITE_SLOT = 0x0100         # for presets/<slot>
+OP_WRITE_RESOURCE = 0x0103     # for GPISettings, SavedSettings
+
+# Path prefix mimics Software Control captures. The unit only inspects
+# the last path segment + the "presets/" anchor; the rest is cosmetic
+# but kept identical for forensic parity.
+_WIRE_NAME_PREFIX = (
+    "/private/var/folders/00/000000000000000000000000000000"
+    "/T/Ultimatte Software Control-PYREST"
+)
+
+
+def restore_unit_from_bytes(host, zip_bytes, connect_timeout=CONNECT_TIMEOUT,
+                            read_timeout=READ_TIMEOUT):
+    """Restore one Ultimatte from in-memory zip bytes.
+
+    Returns (ok: bool, info: dict). info contains the per-resource log:
+        {
+            "presets": [(slot, ok, err_or_None), ...],
+            "gpi": (ok, err_or_None) or None if absent,
+            "saved": (ok, err_or_None) or None if absent,
+            "stopped_at": "<resource>" or None,  # set if a failure aborted
+        }
+    """
+    info = {"presets": [], "gpi": None, "saved": None, "stopped_at": None}
+
+    with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
+        names = zf.namelist()
+
+        # 1) Push all presets first
+        preset_names = sorted(
+            n for n in names if n.startswith("presets/") and not n.endswith("/")
+        )
+        for member in preset_names:
+            slot = member.split("/", 1)[1]
+            blob = zf.read(member)
+            wire_name = f"{_WIRE_NAME_PREFIX}/presets/{slot}"
+            try:
+                upload_one(host, OP_WRITE_SLOT, wire_name, blob,
+                           connect_timeout=connect_timeout,
+                           read_timeout=read_timeout)
+                info["presets"].append((slot, True, None))
+            except Exception as e:
+                info["presets"].append((slot, False, str(e)))
+                info["stopped_at"] = f"preset:{slot}"
+                return False, info
+
+        # 2) GPISettings
+        if "GPISettings" in names:
+            blob = zf.read("GPISettings")
+            wire_name = f"{_WIRE_NAME_PREFIX}/GPISettings"
+            try:
+                upload_one(host, OP_WRITE_RESOURCE, wire_name, blob,
+                           connect_timeout=connect_timeout,
+                           read_timeout=read_timeout)
+                info["gpi"] = (True, None)
+            except Exception as e:
+                info["gpi"] = (False, str(e))
+                info["stopped_at"] = "GPISettings"
+                return False, info
+
+        # 3) SavedSettings last (this one overwrites the live state)
+        if "SavedSettings" in names:
+            blob = zf.read("SavedSettings")
+            wire_name = f"{_WIRE_NAME_PREFIX}/SavedSettings"
+            try:
+                upload_one(host, OP_WRITE_RESOURCE, wire_name, blob,
+                           connect_timeout=connect_timeout,
+                           read_timeout=read_timeout)
+                info["saved"] = (True, None)
+            except Exception as e:
+                info["saved"] = (False, str(e))
+                info["stopped_at"] = "SavedSettings"
+                return False, info
+
+    return True, info

ultimattewire-0.1.0.dev0.dist-info/METADATA

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: ultimattewire
+Version: 0.1.0.dev0
+Summary: Blackmagic Ultimatte 12 archive and restore over its native TCP protocol (Smart Remote 4 compatible zips)
+Author: Lucas Romanenko
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# ultimattewire
+
+ultimattewire is a small, dependency-free Python library that archives and
+restores the configuration of a Blackmagic **Ultimatte 12** or **Ultimatte
+12 4K** keyer over its native TCP protocol. It produces and consumes the same
+zip archives that Blackmagic's Ultimatte Smart Remote 4 (also shipped as
+"Ultimatte Software Control") writes with **Archive All** and reads with
+**Restore**, so an archive taken with this library restores from the vendor
+app and vice versa. Blackmagic does not document the protocol; everything here
+was reverse-engineered from packet captures of the vendor app talking to real
+hardware, which is why the wire details in the code are marked as not to be
+changed without re-validating against a unit.
+
+## Features
+
+- `archive_unit_to_bytes(host)`: pull every saved preset slot plus the `GPISettings` and `SavedSettings` resources into an in-memory zip in Smart Remote's exact layout, with a human-readable annotated state dump riding along.
+- `restore_unit_from_bytes(host, zip_bytes)`: push such a zip back, in the order the vendor app uses, aborting at the first rejected write.
+- Reads the unit's text prelude on TCP 9998 (label, firmware release, live control values, the preset FILE LIST) and does binary slot/resource reads and writes on TCP 9996.
+- Failed reads are omitted from the archive and reported as warnings instead of being written as placeholder bytes that a later restore would push into live hardware.
+- Short reads raise; truncated blobs are never archived.
+- One-retry connects to survive cold-ARP and first-packet hiccups.
+- Per-parameter display ranges for about 150 control values, used to annotate the state dump (raw `0..10000` to percent, frames, pixels).
+- Pure standard library. No logging; results and warnings are returned to the caller.
+
+## Install
+
+```sh
+pip install "git+https://github.com/lucas-romanenko/ultimattewire.git@v0.1.0.dev0"
+```
+
+Python 3.10 or newer. To run the tests from a checkout:
+
+```sh
+pip install ".[test]"
+python -m pytest
+```
+
+## Usage
+
+```python
+from ultimattewire import archive_unit_to_bytes, restore_unit_from_bytes
+
+# Archive one unit. The label comes from the unit's own Label field.
+zip_bytes, info = archive_unit_to_bytes("192.0.2.21")
+with open(f"{info['label']}.zip", "wb") as f:
+    f.write(zip_bytes)
+print(info["slots"], info["warnings"])
+
+# Restore it (or a Smart Remote "Archive All" zip) onto another unit.
+with open("Keyer_A.zip", "rb") as f:
+    ok, report = restore_unit_from_bytes("192.0.2.22", f.read())
+if not ok:
+    print("stopped at", report["stopped_at"])
+```
+
+A zip produced by this library can be opened with Smart Remote 4's Restore
+unchanged, and a Smart Remote "Archive All" zip can be passed straight to
+`restore_unit_from_bytes`.
+
+## Protocol notes
+
+This is the reverse-engineered part and the most useful thing to read before
+changing anything.
+
+### How it was determined
+
+The wire format was recovered from packet captures of Blackmagic's Ultimatte
+Smart Remote 4 / Ultimatte Software Control performing **Archive All** and
+**Restore** against a real Ultimatte 12 4K. The library was then validated by
+round-tripping archives through the vendor app: a zip produced here restores
+from Smart Remote, and a Smart Remote zip restores through this code. The
+display ranges come from the Ultimatte 12 Operations Manual (February 2026
+revision) and from Smart Remote 4 panel screenshots, not from the wire.
+
+### Two TCP channels
+
+| Port | Role | Framing |
+|---|---|---|
+| 9998 | Text control channel | The unit streams a text prelude on connect |
+| 9996 | Binary settings channel | One request per TCP connection, big-endian length-prefixed frames |
+
+### The 9998 prelude
+
+On connect the unit immediately sends a text prelude and, if the client does
+not continue with the interactive greeting the vendor app uses, may close the
+connection partway through. The library reads until the literal
+`END PRELUDE:` marker, then drains for a further 0.3 s, and returns whatever
+arrived (decoded as UTF-8 with replacement). The prelude is a sequence of
+sections introduced by an upper-case header ending in a colon, each holding
+`key: value` lines. The parts the library uses:
+
+- `Label: <name>`: the unit's user-assigned name. Sanitised to
+  `[A-Za-z0-9._-]` for use as the archive filename root.
+- `Software Release: <x.y>`: the firmware version. Not used by the library
+  itself, but this is the field to read if you want it.
+- `CONTROL:` and `CONTROL DEFAULT:`: the live and default control values as
+  `Name: raw` lines, raw integers mostly in `0..10000`. Only used for the
+  annotated text dump.
+- `FILE LIST:`: one saved preset slot name per line. This is the list of
+  slots the archive will read.
+
+Section extraction is a regular expression anchored on the header and
+terminated by the next all-caps header or `END PRELUDE:`; two pitfalls
+already hit and fixed are recorded in `_preamble.py` (a `$` anchor that
+truncated multi-line FILE LISTs, and a `\s*` that let an empty section
+swallow the next one).
+
+### The 9996 binary channel
+
+Every request opens its own TCP connection; the unit closes it after
+replying.
+
+Read (`binary_request`):
+
+```
+send  [opcode: u16 BE][len: u32 BE][payload: len bytes]
+recv  [len: u32 BE][body: len bytes]
+```
+
+Write (`upload_one`):
+
+```
+send  [opcode: u16 BE][name_len: u32 BE][name][data_len: u32 BE][data][0x00]
+recv  6 bytes of 0x00  (success ACK)
+```
+
+Known opcodes:
+
+| Opcode | Direction | Payload / name | Meaning |
+|---|---|---|---|
+| `0x0000` | read | preset slot name from FILE LIST | read a saved preset blob |
+| `0x0003` | read | `GPISettings` or `SavedSettings` | read a named resource |
+| `0x0100` | write | `.../presets/<slot>` | write a preset slot (mirror of `0x0000`) |
+| `0x0103` | write | `.../GPISettings` or `.../SavedSettings` | write a resource (mirror of `0x0003`) |
+
+Details that matter and were established by experiment:
+
+- The trailing `0x00` on a write frame is mandatory. Without it the unit
+  silently declines to ACK.
+- The vendor app puts the full filesystem path of the extracted zip member
+  into the name field (a macOS temporary directory under
+  `Ultimatte Software Control-PYREST/...`). The unit appears to inspect only
+  the last path segment, and for slot writes the presence of a `presets/`
+  segment. The library sends the same path shape for parity.
+- The ACK is six zero bytes, but the unit closes the socket so quickly after
+  sending it that a client can see EOF after fewer than six. The library
+  accepts any all-zero prefix as success; any non-zero byte is treated as a
+  rejection and raised as `IOError`.
+- A short read of the 4-byte length header, including an immediate clean
+  EOF, and a short body read both raise `IOError`. An empty resource whose
+  header says length 0 returns `b""` cleanly.
+- Blob contents are opaque. The library never parses preset or resource
+  bytes; it moves them verbatim.
+
+### Archive layout
+
+The zip must match the vendor app byte for byte in structure, or its Restore
+rejects it. Members in this order, with explicit directory entries carrying
+`0o40755` external attributes:
+
+```
+images/                       (empty directory entry)
+GPISettings                   (raw bytes, no length prefix)
+SavedSettings                 (raw bytes, no length prefix)
+quickfiles/                   (empty directory entry)
+presets/                      (explicit directory entry; required)
+presets/<slot>                (one per FILE LIST entry)
+<label>_config_readable.txt   (this library's addition; ignored by the vendor app)
+```
+
+### Restore order
+
+1. Every `presets/<slot>` member, sorted by name, with opcode `0x0100`.
+2. `GPISettings` with opcode `0x0103`, if present.
+3. `SavedSettings` with opcode `0x0103`, if present. It overwrites the live
+   state, so it goes last.
+
+The first failed write aborts the run; `restore_unit_from_bytes` returns
+`(False, report)` with `report["stopped_at"]` naming the member. Members
+that are not presets or the two resources are ignored, which is how the
+annotated text dump rides along harmlessly.
+
+### Timeouts and retries
+
+Connect timeout 5 s, read timeout 30 s on writes, 2 s quiet timeout while
+reading the prelude. Every connect is retried once after 250 ms because a
+cold unit regularly refuses or times out the very first packet and answers
+the second.
+
+### Verified against
+
+- Ultimatte 12 4K, the unit the captures were taken from and the round-trip
+  tests were run on. The docstrings also name the Ultimatte 12 (HD) as a
+  target of the same protocol.
+- The firmware version of the bench unit was not recorded at capture time.
+  Read it from the prelude's `Software Release` line on your own unit and
+  treat any difference from the behaviour above as something to re-verify.
+
+### Unverified or guessed
+
+- Whether the unit reads anything in the write name field beyond the last
+  segment and the `presets/` anchor. The full vendor path is sent to be safe.
+- Whether non-zero ACK bytes carry an error code. They are treated as a
+  generic rejection.
+- `images/` and `quickfiles/` are always written as empty directories. A unit
+  that actually holds images or quick files would not have them archived by
+  this library, and no opcode for them is known.
+- Other opcodes almost certainly exist (the gaps between `0x0000` and
+  `0x0003`, and between `0x0100` and `0x0103`, are suggestive). None have been
+  probed.
+- The interactive greeting the vendor app sends on 9998 after the prelude is
+  not implemented; the library only ever reads the prelude.
+- `read_preamble` is bounded per `recv` but has no overall deadline or size
+  cap; a unit that never stops sending would keep it reading.
+- Ultimatte 12 HD Mini and other models were not tested.
+- The display-range table is an interpretation of the manual and the panel
+  UI, not wire data. It affects only the readable text dump.
+
+## License
+
+MIT. See `LICENSE`.

ultimattewire-0.1.0.dev0.dist-info/RECORD

@@ -0,0 +1,12 @@
+ultimattewire/__init__.py,sha256=Vk9fIXY1H8I0WbRlIbqKKjxEeh61EtPgHTmAtpmmnJ4,575
+ultimattewire/_preamble.py,sha256=-cJte_GK-zEovS-3uJmEoiE9F0VlWyq2FszEReFcTjw,2694
+ultimattewire/_protocol.py,sha256=Syp40QhvwaTjaoJOJIPJ0PNP2KoPRLe0k_6odS-WGz0,5449
+ultimattewire/profile/__init__.py,sha256=SoV019phlaOnlJkLHqL0Hngv7zJ0o6yHU3RuVNPgGYA,527
+ultimattewire/profile/_ranges.py,sha256=GiD6EcsIxXRkuZOnZMOXh917yO6ye4WiZ1Jd1OhRvFE,14273
+ultimattewire/profile/archive.py,sha256=KN5cVcWYUijUeJ2sXqi8OowVFUKHdHeQ6bLBvCo1WgI,5366
+ultimattewire/profile/restore.py,sha256=dqnBDWXlbal5_EkX-80F2X0x-xdsCs2Iu-k9TGq_yV4,4617
+ultimattewire-0.1.0.dev0.dist-info/licenses/LICENSE,sha256=Mzt4-lP7NpZGbjxKnwYliRFTN_K-BJhL4CBIMWJO_jM,1072
+ultimattewire-0.1.0.dev0.dist-info/METADATA,sha256=x6lNg9kt4-YuXsoSRjZMDTHadVs71obpQL9ArK42fRo,10428
+ultimattewire-0.1.0.dev0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ultimattewire-0.1.0.dev0.dist-info/top_level.txt,sha256=wLRvQ_q4o_hCq4ONjvw3OiGbeDW7g-USg4BBjO0OL_c,14
+ultimattewire-0.1.0.dev0.dist-info/RECORD,,

ultimattewire-0.1.0.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ultimattewire-0.1.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lucas Romanenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ultimattewire-0.1.0.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ultimattewire