mx-remote 5.0.0__tar.gz → 5.2.0__tar.gz

{mx_remote-5.0.0 → mx_remote-5.2.0}/CLAUDE.md

@@ -52,6 +52,19 @@ replaced. Its expected values come from firmware behaviour rather than from this
 decoder, which is the property a synthetic fixture cannot have — assert against
 something external, or a fixture only proves the decoder agrees with itself.
 
+Two things a test of a *command* must do, both of which look like coverage
+when they are missing:
+
+- **Assert both directions.** A command that returns False for an unrelated
+  reason satisfies a failure-only assertion on its own, so the success case is
+  what gives the failure case meaning.
+- **Pick an input that can reach the send.** Every multiviewer getter reads
+  `UNKNOWN` until a config frame arrives, and each setter returns True without
+  transmitting when the value already matches — so a table built from the first
+  enum member, which is `UNKNOWN`, never transmits at all.
+
+`tests/txresult.py` is the worked example of both.
+
 Validate wire changes against live hardware as well, by running `mxr` or
 replaying a capture file with `mxr -i`.
 

{mx_remote-5.0.0 → mx_remote-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mx_remote
-Version: 5.0.0
+Version: 5.2.0
 Summary: Python 3 library for interfacing with MX Remote compatible devices
 Project-URL: Homepage, https://github.com/opdenkamp/mx-remote/
 Project-URL: Documentation, https://github.com/opdenkamp/mx-remote/

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/Interface.py

@@ -173,10 +173,96 @@ class ConnectStatus(IntEnum):
     def __repr__(self) -> str:
         return str(self)
 
+class VideoColourSpace(IntEnum):
+    '''Video colour space encoding format.'''
+    RGB = 0
+    YUV444 = 1
+    YUV422 = 2
+    YUV420 = 3
+
+    def __str__(self) -> str:
+        if self.value == 0:
+            return 'RGB'
+        if self.value == 1:
+            return '4:4:4'
+        if self.value == 2:
+            return '4:2:2'
+        if self.value == 3:
+            return '4:2:0'
+        return 'unknown'
+
+class VideoSignalDetails:
+    """
+    Video format of a bay: CTA-861 svd, colour space, bit depth, frame rate kind.
+
+    ``from_report`` says where it came from, because the two sources do not carry
+    the same currency. A signal status report is the live format and arrives on a
+    signal change. The bay config snapshot is a fallback for a bay no report has
+    been seen for: it refreshes on the bay config broadcast cycle, so it can lag a
+    change by a broadcast interval.
+
+    ``bpp`` is a bit depth in both cases, not a wire index. None means no format
+    is set; 0 means one is set whose depth is not known, and those are different
+    answers.
+    """
+    def __init__(self, svd:int|None, colour:VideoColourSpace|None, bpp:int|None,
+                 non_int:bool|None, from_report:bool) -> None:
+        self._svd = svd
+        self._colour = colour
+        self._bpp = bpp
+        self._non_int = non_int
+        self._from_report = from_report
+
+    @property
+    def svd(self) -> int|None:
+        '''CTA-861 short video descriptor, or None when no format is set.'''
+        return self._svd
+
+    @property
+    def colour(self) -> VideoColourSpace|None:
+        '''Colour space, or None when no format is set or the value is unknown to this build.'''
+        return self._colour
+
+    @property
+    def bpp(self) -> int|None:
+        '''Bit depth, 0 when a format is set whose depth is not known.'''
+        return self._bpp
+
+    @property
+    def non_int(self) -> bool|None:
+        '''True for a non-integer (1000/1001) frame rate.'''
+        return self._non_int
+
+    @property
+    def from_report(self) -> bool:
+        '''True when this came from a signal status report rather than the bay config snapshot.'''
+        return self._from_report
+
+    def __eq__(self, other:Any) -> bool:
+        if not isinstance(other, VideoSignalDetails):
+            return NotImplemented
+        return (self._svd == other._svd) and (self._colour == other._colour) \
+            and (self._bpp == other._bpp) and (self._non_int == other._non_int)
+
+    def __hash__(self) -> int:
+        return hash((self._svd, self._colour, self._bpp, self._non_int))
+
+    def __str__(self) -> str:
+        if self._svd is None:
+            return 'no format'
+        src = 'report' if self._from_report else 'bay config'
+        bpp = f', {self._bpp}bpp' if self._bpp else ''
+        return f'svd {self._svd}, {self._colour}{bpp} ({src})'
+
+    def __repr__(self) -> str:
+        return str(self)
+
 class SignalStatus:
-    def __init__(self, detected:bool, description:str|None=None) -> None:
+    def __init__(self, detected:bool, description:str|None=None,
+                 details:VideoSignalDetails|None=None) -> None:
         self._detected = detected
         self._description = description
+        self._details = details
 
     @property
     def detected(self) -> bool:
@@ -186,6 +272,11 @@ class SignalStatus:
     def description(self) -> str|None:
         return self._description
 
+    @property
+    def details(self) -> VideoSignalDetails|None:
+        '''Structured video format, or None when the report carried no valid stream.'''
+        return self._details
+
 class AmpDolbySettings:
     """
     Dolby Digital settings for an amplifier
@@ -984,6 +1075,15 @@ class BayBase(ABC):
     def signal_type(self) -> str:
         '''Audio or video signal type'''
 
+    @property
+    @abstractmethod
+    def video_details(self) -> VideoSignalDetails|None:
+        '''Current video format, or None if neither source has carried one.
+
+        Prefers the signal status report, which arrives on a signal change, and
+        falls back to the bay config snapshot for a bay no report has been seen
+        for. Read from_report to tell which one this is.'''
+
     @property
     @abstractmethod
     def hpd_detected(self) -> bool:
@@ -1795,7 +1895,19 @@ class DeviceBase(ABC):
     @property
     @abstractmethod
     def protocol(self) -> int:
-        pass
+        """Highest protocol version this device advertises, or 0 if none has been seen."""
+
+    @abstractmethod
+    def supports_opcode(self, opcode:int) -> bool:
+        """True when this device can receive opcode.
+
+        Each opcode has a minimum protocol version, and a device whose cap is
+        lower drops the frame without answering - there is no NAK at any layer,
+        so an ungated send looks like success. A device that has advertised no
+        version yet returns True: refusing on that would break every send made
+        before the first hello arrives, and the firmware itself only compares
+        against a version it has.
+        """
 
     @property
     @abstractmethod

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/Interface.pyi

@@ -48,12 +48,35 @@ class ConnectStatus(IntEnum):
     CONNECTED: int
     DISCONNECTED: int
 
+class VideoColourSpace(IntEnum):
+    RGB: int
+    YUV444: int
+    YUV422: int
+    YUV420: int
+
+class VideoSignalDetails:
+    def __init__(self, svd: int | None, colour: VideoColourSpace | None, bpp: int | None, non_int: bool | None, from_report: bool) -> None: ...
+    @property
+    def svd(self) -> int | None: ...
+    @property
+    def colour(self) -> VideoColourSpace | None: ...
+    @property
+    def bpp(self) -> int | None: ...
+    @property
+    def non_int(self) -> bool | None: ...
+    @property
+    def from_report(self) -> bool: ...
+    def __eq__(self, other: Any) -> bool: ...
+    def __hash__(self) -> int: ...
+
 class SignalStatus:
-    def __init__(self, detected: bool, description: str | None = None) -> None: ...
+    def __init__(self, detected: bool, description: str | None = None, details: VideoSignalDetails | None = None) -> None: ...
     @property
     def detected(self) -> bool: ...
     @property
     def description(self) -> str | None: ...
+    @property
+    def details(self) -> VideoSignalDetails | None: ...
 
 class AmpDolbySettings:
     mode: int
@@ -420,6 +443,9 @@ class BayBase(ABC):
     def signal_type(self) -> str: ...
     @property
     @abstractmethod
+    def video_details(self) -> VideoSignalDetails | None: ...
+    @property
+    @abstractmethod
     def hpd_detected(self) -> bool: ...
     @property
     @abstractmethod
@@ -796,6 +822,8 @@ class DeviceBase(ABC):
     @property
     @abstractmethod
     def protocol(self) -> int: ...
+    @abstractmethod
+    def supports_opcode(self, opcode: int) -> bool: ...
     @property
     @abstractmethod
     def is_mesh_master(self) -> bool: ...

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/const.py

@@ -14,7 +14,7 @@ Default communication modes:
 """
 import os
 
-VERSION = '5.0.0'
+VERSION = '5.2.0'
 __version__ = VERSION
 
 MX_BCAST_UDP_PORT = 8811
@@ -26,6 +26,17 @@ MX_MCAST_UDP_IP = '224.8.8.8'
 MX_MCAST_UDP_PORT = 8812
 """UDP port used in multicast mode (default)."""
 
+MXR_HELLO_INTERVAL_MIN = 2.5
+"""Shortest gap between hello announcements, in seconds (firmware ``hello_timeout`` minimum)."""
+
+MXR_HELLO_INTERVAL_RAND = 2.5
+"""Random spread added to each hello interval, in seconds.
+
+Mirrors ``rand_timeout_init(&mxr_class->hello_timeout, 2500, 2500)``: the delay is
+re-drawn after every hello that is sent, so devices announcing on the same mesh do
+not converge into synchronised bursts.
+"""
+
 V2IP_UDP_PORT_VIDEO = 50020
 """Default destination UDP port for a V2IP video stream (firmware ``V2IP_UDP_PORT_VIDEO``)."""
 

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/const.pyi

@@ -5,6 +5,8 @@ __version__ = VERSION
 MX_BCAST_UDP_PORT: int
 MX_MCAST_UDP_IP: str
 MX_MCAST_UDP_PORT: int
+MXR_HELLO_INTERVAL_MIN: float
+MXR_HELLO_INTERVAL_RAND: float
 V2IP_UDP_PORT_VIDEO: int
 V2IP_UDP_PORT_ANC: int
 V2IP_UDP_PORT_AUDIO: int

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/Constants.py

@@ -651,6 +651,10 @@ class EdidProfile(IntEnum):
 			return '4K HDR Dolby Atmos'
 		if (self.value >= EdidProfile.SINK_1.value) and (self.value <= EdidProfile.SINK_32.value):
 			return f'copy from sink #{self.value - EdidProfile.SINK_1.value + 1}'
+		if self.value == EdidProfile.UNKNOWN.value:
+			# decode_enum lands here for any value this build has no member for,
+			# so it is a profile we cannot name, not one somebody configured
+			return 'unknown'
 		return f"custom #{self.value}"
 
 	TEMPLATE_1080P_STEREO = 0

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameAmpZoneSettings.py

@@ -65,7 +65,7 @@ class FrameAmpZoneSettings(FrameBase):
         for r in range(5):
             payload.append(settings.eq_right[r] & 0xFF)
         payload += bytes([0, 0]) # padding
-        return FrameBase.construct_base(mxr=mxr, opcode=0x3D, protocol=0x1C, payload=payload)
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x3D, protocol=0x1C, payload=payload)
 
     @property
     def target_device(self) -> DeviceBase|None:

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameBase.py

@@ -7,6 +7,8 @@
 
 '''Base class and utilities for decoded MX Remote protocol frames.'''
 
+from typing import Any
+import logging
 from functools import cached_property
 import time
 from .Constants import MXR_OPCODE_VERSIONS, MXR_PROTOCOL_VERSION
@@ -14,6 +16,8 @@ from .FrameHeader import FrameHeader
 from ..Interface import DeviceBase, DeviceRegistry, BayBase
 from ..Uid import MxrDeviceUid
 
+_LOGGER = logging.getLogger(__name__)
+
 def append_payload_str(payload:list[int], value:str, sz:int) -> list[int]:
     '''Append a fixed-size ASCII string to a payload byte list, zero-padded to sz.
 
@@ -46,14 +50,19 @@ class FrameBase:
         return MXR_OPCODE_VERSIONS.get(opcode, MXR_PROTOCOL_VERSION)
 
     @staticmethod
-    def construct_base(mxr:DeviceRegistry, opcode:int, protocol:int|None=None, payload:bytes=bytes([]), size:int|None=None) -> 'FrameBase|None':
+    def construct_base(mxr:DeviceRegistry, opcode:int, protocol:int|None=None, payload:bytes=bytes([]), size:int|None=None, target:Any=None) -> 'FrameBase|None':
         '''Construct a new frame for transmission with the given opcode and payload.
 
         Leave protocol unset unless the payload really does need a newer
         receiver than the opcode itself does; it then defaults to the opcode's
-        own minimum from MXR_OPCODE_VERSIONS.'''
+        own minimum from MXR_OPCODE_VERSIONS.
+
+        Pass target for anything addressed at one device, so a frame it cannot
+        receive is refused here rather than sent into silence.'''
         if (protocol is None):
             protocol = FrameBase.opcode_protocol(opcode)
+        if not FrameBase.target_supports(mxr=mxr, target=target, opcode=opcode):
+            return None
         header = FrameHeader.construct(mxr=mxr, opcode=opcode, protocol=protocol)
         if (header is None):
             return None
@@ -66,6 +75,28 @@ class FrameBase:
         rv.payload = payload
         return rv
 
+    @staticmethod
+    def target_supports(mxr:DeviceRegistry, target:Any, opcode:int) -> bool:
+        '''Whether a frame addressed at target can be received by it.
+
+        Accepts what the constructFrame helpers are given: a device, a bay, a
+        uid, or None for a broadcast, which has no single target and is always
+        allowed.
+        '''
+        if (target is None):
+            return True
+        device = getattr(target, 'device', None) or (target if hasattr(target, 'supports_opcode') else None)
+        if (device is None):
+            device = mxr.get_by_uid(target) if isinstance(target, (str, bytes, MxrDeviceUid)) else None
+        if (device is None) or not hasattr(device, 'supports_opcode'):
+            return True
+        if device.supports_opcode(opcode):
+            return True
+        _LOGGER.warning(
+            f"not sending opcode {opcode:02X} to {device}: it advertises protocol "
+            f"{device.protocol:02X} and the opcode needs {FrameBase.opcode_protocol(opcode):02X}")
+        return False
+
     @property
     def mxr(self) -> DeviceRegistry:
         '''Remote instance.'''

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameBase.pyi

@@ -4,6 +4,7 @@ from .Constants import MXR_OPCODE_VERSIONS as MXR_OPCODE_VERSIONS, MXR_PROTOCOL_
 from .FrameHeader import FrameHeader as FrameHeader
 from _typeshed import Incomplete
 from functools import cached_property
+from typing import Any
 
 def append_payload_str(payload: list[int], value: str, sz: int) -> list[int]: ...
 
@@ -14,7 +15,9 @@ class FrameBase:
     @staticmethod
     def opcode_protocol(opcode: int) -> int: ...
     @staticmethod
-    def construct_base(mxr: DeviceRegistry, opcode: int, protocol: int | None = None, payload: bytes = ..., size: int | None = None) -> FrameBase | None: ...
+    def construct_base(mxr: DeviceRegistry, opcode: int, protocol: int | None = None, payload: bytes = ..., size: int | None = None, target: Any = None) -> FrameBase | None: ...
+    @staticmethod
+    def target_supports(mxr: DeviceRegistry, target: Any, opcode: int) -> bool: ...
     @property
     def mxr(self) -> DeviceRegistry: ...
     @property

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameBayHide.py

@@ -22,7 +22,7 @@ class FrameBayHide(FrameBase):
             bytes([(target.port >> 0) & 0xFF, (target.port >> 8) & 0xFF]) + \
             bytes([1 if hidden else 0]) + \
             bytes([0 for _ in range(5)])
-        return FrameBase.construct_base(mxr=mxr, opcode=0x27, payload=payload)
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x27, payload=payload)
 
     @cached_property
     def target(self) -> DeviceBase|None:

mx_remote-5.2.0/mx_remote/proto/FrameEDIDProfile.py

@@ -0,0 +1,53 @@
+######################################################
+##            MX Remote Python Interface            ##
+##                                                  ##
+## author: Lars Op den Kamp (lars@opdenkamp-it.nl)  ##
+## copyright (c) 2021-2026 Op den Kamp IT Solutions ##
+######################################################
+'''Protocol frame for EDID profile change commands.'''
+
+from .FrameBase import FrameBase
+from ..Interface import DeviceRegistry, DeviceBase, EdidProfile, MxrDeviceUid
+from .Constants import decode_enum
+
+class FrameEDIDProfile(FrameBase):
+    '''Change an EDID profile on a target device.'''
+    @staticmethod
+    def construct(mxr:DeviceRegistry, target:DeviceBase, profile:EdidProfile) -> FrameBase|None:
+        '''Build an EDID profile change frame for transmission.'''
+        payload = target.remote_id.byte_value + \
+            bytes([(profile.value >> 0) & 0xFF, (profile.value >> 8) & 0xFF]) + \
+            bytes([0 for _ in range(6)])
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x34, payload=payload)
+
+    @property
+    def target_uid(self) -> MxrDeviceUid|None:
+        '''Device whose EDID profile is being set.'''
+        return self.payload_uuid(0)
+
+    @property
+    def target_device(self) -> DeviceBase|None:
+        return self.mxr.get_by_uid(self.target_uid)
+
+    @property
+    def profile_raw(self) -> int|None:
+        '''Profile as carried on the wire, before mapping to a local one.'''
+        return self.payload_u16(16)
+
+    @property
+    def profile(self) -> EdidProfile|None:
+        '''Requested EDID profile.
+
+        A value this build has no member for reads as EdidProfile.UNKNOWN rather
+        than raising or being folded into a real profile. Read profile_raw when
+        the distinction matters.
+        '''
+        return decode_enum(EdidProfile, self.profile_raw)
+
+    def __str__(self) -> str:
+        # The frame names no bay because it never needs to: the receiver applies it
+        # to MBAY_ID_0, its own input bay, so a device is the whole address.
+        target = self.target_device if (self.target_device is not None) else self.target_uid
+        profile = f"{self.profile} ({self.profile_raw})" \
+            if (self.profile == EdidProfile.UNKNOWN) else str(self.profile)
+        return f"set edid profile: {target} input 0 -> {profile}"

mx_remote-5.2.0/mx_remote/proto/FrameEDIDProfile.pyi

@@ -0,0 +1,15 @@
+from ..Interface import DeviceBase as DeviceBase, DeviceRegistry as DeviceRegistry, EdidProfile as EdidProfile, MxrDeviceUid as MxrDeviceUid
+from .Constants import decode_enum as decode_enum
+from .FrameBase import FrameBase as FrameBase
+
+class FrameEDIDProfile(FrameBase):
+    @staticmethod
+    def construct(mxr: DeviceRegistry, target: DeviceBase, profile: EdidProfile) -> FrameBase | None: ...
+    @property
+    def target_uid(self) -> MxrDeviceUid | None: ...
+    @property
+    def target_device(self) -> DeviceBase | None: ...
+    @property
+    def profile_raw(self) -> int | None: ...
+    @property
+    def profile(self) -> EdidProfile | None: ...

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameMeshOperation.py

@@ -55,7 +55,7 @@ class FrameMeshOperation(FrameBase):
             payload += option.remote_id.byte_value
         else:
             payload += bytes([0 for _ in range(16)])
-        return FrameBase.construct_base(mxr=mxr, opcode=0x3B, payload=payload)
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x3B, payload=payload)
 
     @cached_property
     def operation(self) -> MeshOperation|None:

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameRCAction.py

@@ -21,7 +21,7 @@ class FrameRCAction(FrameBase):
         '''Build an RC action frame for transmission.'''
         payload = target.device.remote_id.byte_value
         payload += bytes([(target.port & 0xFF), ((target.port >> 8) & 0xFF), (int(action.value) & 0xFF), ((int(action.value) >> 8) & 0xFF)])
-        return FrameBase.construct_base(mxr=mxr, opcode=0x0E, payload=payload)
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x0E, payload=payload)
 
     @cached_property
     def bay(self) -> BayBase|None:

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameReboot.py

@@ -15,7 +15,7 @@ class FrameReboot(FrameBase):
     @staticmethod
     def construct(mxr:DeviceRegistry, target:DeviceBase) -> FrameBase|None:
         '''Build a reboot frame for transmission to the target device.'''
-        return FrameBase.construct_base(mxr=mxr, opcode=0x28, payload=target.remote_id.byte_value)
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x28, payload=target.remote_id.byte_value)
     
     def __str__(self) -> str:
         return "reboot"

mx_remote-5.2.0/mx_remote/proto/FrameSetName.py

@@ -0,0 +1,62 @@
+######################################################
+##            MX Remote Python Interface            ##
+##                                                  ##
+## author: Lars Op den Kamp (lars@opdenkamp-it.nl)  ##
+## copyright (c) 2021-2026 Op den Kamp IT Solutions ##
+######################################################
+'''Protocol frame for changing a bay name on a device.'''
+
+from .Constants import MXR_DEVICE_NAME_LEN
+from .FrameBase import FrameBase
+from ..Interface import DeviceRegistry, BayBase, DeviceBase, MxrDeviceUid
+
+class FrameSetName(FrameBase):
+    '''Change a bay name.'''
+    @staticmethod
+    def construct(mxr:DeviceRegistry, target:BayBase, name:str) -> FrameBase|None:
+        '''Build a bay name change frame for transmission.'''
+        # 15, not 16: the receiver copies MXR_DEVICE_NAME_LEN - 1 bytes and
+        # terminates, so a name filling the field is stored one short. Sending
+        # all 16 means the bay ends up named something other than what was
+        # asked for, with success reported either way.
+        name = name[:MXR_DEVICE_NAME_LEN - 1]
+        name_bytes = name.encode(encoding='ascii', errors='replace').ljust(MXR_DEVICE_NAME_LEN, b'\x00')
+        payload = target.device.remote_id.byte_value + \
+            bytes([(target.port >> 0) & 0xFF, (target.port >> 8) & 0xFF]) + \
+            name_bytes
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x22, protocol=0x11, payload=payload)
+
+    @property
+    def target_uid(self) -> MxrDeviceUid|None:
+        '''Device whose bay is being renamed.'''
+        return self.payload_uuid(0)
+
+    @property
+    def target_device(self) -> DeviceBase|None:
+        return self.mxr.get_by_uid(self.target_uid)
+
+    @property
+    def port(self) -> int|None:
+        '''Port id of the bay being renamed (mbay_port_id, a u16).'''
+        return self.payload_u16(16)
+
+    @property
+    def bay(self) -> BayBase|None:
+        return self.payload_bay(device=self.target_device, idx=16, u16=True)
+
+    @property
+    def name(self) -> str|None:
+        '''The new name, read from its fixed 16-byte field.
+
+        The field carries no terminator of its own, so a name that fills it has
+        none and must not be read as a C string: read it at its width. A sender
+        that fills all MXR_DEVICE_NAME_LEN bytes is readable here, even though a
+        receiver keeps only the first MXR_DEVICE_NAME_LEN - 1 of them.
+        '''
+        return self.payload_str(18, 16)
+
+    def __str__(self) -> str:
+        target = self.bay if (self.bay is not None) else self.target_device
+        if (target is None):
+            return f"set bay name: port {self.port} -> '{self.name}'"
+        return f"set bay name: {target} -> '{self.name}'"

mx_remote-5.2.0/mx_remote/proto/FrameSetName.pyi

@@ -0,0 +1,17 @@
+from ..Interface import BayBase as BayBase, DeviceBase as DeviceBase, DeviceRegistry as DeviceRegistry, MxrDeviceUid as MxrDeviceUid
+from .Constants import MXR_DEVICE_NAME_LEN as MXR_DEVICE_NAME_LEN
+from .FrameBase import FrameBase as FrameBase
+
+class FrameSetName(FrameBase):
+    @staticmethod
+    def construct(mxr: DeviceRegistry, target: BayBase, name: str) -> FrameBase | None: ...
+    @property
+    def target_uid(self) -> MxrDeviceUid | None: ...
+    @property
+    def target_device(self) -> DeviceBase | None: ...
+    @property
+    def port(self) -> int | None: ...
+    @property
+    def bay(self) -> BayBase | None: ...
+    @property
+    def name(self) -> str | None: ...

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameSignalStatusNew.py

@@ -9,29 +9,12 @@
 from enum import IntEnum
 from functools import cached_property
 from .FrameBase import FrameBase
-from ..Interface import BayBase, SignalStatus
+from ..Interface import VideoColourSpace, VideoSignalDetails, BayBase, SignalStatus
 from ..Uid import MxrDeviceUid
 import struct
 from .Svd import SvdMap, Svd
 from .Constants import BayStatusMask, MxrSignalType, decode_enum
 
-class VideoColourSpace(IntEnum):
-    '''Video colour space encoding format.'''
-    RGB = 0
-    YUV444 = 1
-    YUV422 = 2
-    YUV420 = 3
-
-    def __str__(self) -> str:
-        if self.value == 0:
-            return 'RGB'
-        if self.value == 1:
-            return '4:4:4'
-        if self.value == 2:
-            return '4:2:2'
-        if self.value == 3:
-            return '4:2:0'
-        return 'unknown'
 
 class AvDetailsSupportFlags:
     '''Bitmask indicating which AV detail fields are present in the frame.'''
@@ -318,9 +301,17 @@ class FrameSignalStatusNew(FrameBase):
                 if self.stream_flags.video_hdr:
                     signal_type += ' HDR'
             signal_type += f' / {self.frame_rate}Hz'
+            details = VideoSignalDetails(
+                svd=self.video.svd.id,
+                colour=self.video.colour_space,
+                bpp=self.video.colour_depth,
+                non_int=(self.stream_flags is not None) and self.stream_flags.video_non_int_clock,
+                from_report=True)
         else:
             signal_type = 'No Signal'
-        bay.on_mxr_update(SignalStatus(detected=self.stream_valid, description=signal_type))
+            details = None
+        bay.on_mxr_update(SignalStatus(detected=self.stream_valid, description=signal_type,
+                                       details=details))
 
     def __str__(self) -> str:
         if (self.payload is None):

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameSignalStatusNew.pyi

@@ -1,18 +1,12 @@
-from ..Interface import BayBase as BayBase, SignalStatus as SignalStatus
+from ..Interface import BayBase as BayBase, SignalStatus as SignalStatus, VideoColourSpace as VideoColourSpace, VideoSignalDetails as VideoSignalDetails
 from ..Uid import MxrDeviceUid as MxrDeviceUid
 from .Constants import BayStatusMask as BayStatusMask, MxrSignalType as MxrSignalType, decode_enum as decode_enum
 from .FrameBase import FrameBase as FrameBase
 from .Svd import Svd as Svd, SvdMap as SvdMap
 from _typeshed import Incomplete
-from enum import IntEnum
+from enum import IntEnum as IntEnum
 from functools import cached_property
 
-class VideoColourSpace(IntEnum):
-    RGB: int
-    YUV444: int
-    YUV422: int
-    YUV420: int
-
 class AvDetailsSupportFlags:
     data: Incomplete
     def __init__(self, data: int) -> None: ...

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameTXRCAction.py

@@ -30,7 +30,7 @@ class FrameTXRCAction(FrameBase):
         '''Build an RC action frame for transmission to the target bay.'''
         payload = target.device.remote_id.byte_value
         payload += bytes([(target.port & 0xFF), ((target.port >> 8) & 0xFF), (int(action.value) & 0xFF), ((int(action.value) >> 8) & 0xFF)])
-        return FrameBase.construct_base(mxr=mxr, opcode=0x0E, payload=payload)
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x0E, payload=payload)
 
     @cached_property
     def target_device(self) -> DeviceBase|None:

{mx_remote-5.0.0 → mx_remote-5.2.0}/mx_remote/proto/FrameTXRCKey.py

@@ -30,7 +30,7 @@ class FrameTXRCKey(FrameBase):
         payload = target.device.remote_id.byte_value
         payload += bytes([(target.port & 0xFF), ((target.port >> 8) & 0xFF),
                           (int(key.value) & 0xFF), ((int(key.value) >> 8) & 0xFF)])
-        return FrameBase.construct_base(mxr=mxr, opcode=0x0C, payload=payload)
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x0C, payload=payload)
 
     @cached_property
     def target_uid(self) -> MxrDeviceUid|None: