mx-remote 5.1.0__tar.gz → 5.3.0__tar.gz

{mx_remote-5.1.0 → mx_remote-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mx_remote
-Version: 5.1.0
+Version: 5.3.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.1.0 → mx_remote-5.3.0}/mx_remote/const.py

@@ -14,7 +14,7 @@ Default communication modes:
 """
 import os
 
-VERSION = '5.1.0'
+VERSION = '5.3.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.1.0 → mx_remote-5.3.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.1.0 → mx_remote-5.3.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.1.0 → mx_remote-5.3.0}/mx_remote/proto/Factory.py

@@ -108,9 +108,6 @@ def _mxr_frame_factory(hdr:FrameHeader, timestamp:float) -> FrameBase|None:
 	if hdr.opcode == 0x1F:
 		from .FrameV2IPSourceSwitch import FrameV2IPSourceSwitch
 		return FrameV2IPSourceSwitch(header=hdr, timestamp=timestamp)
-	if hdr.opcode == 0x16:
-		from .FramePDUState import FramePDUState
-		return FramePDUState(header=hdr, timestamp=timestamp)
 	if hdr.opcode == 0x20:
 		from .FrameV2IPLink import FrameV2IPLinkStatus
 		return FrameV2IPLinkStatus(header=hdr, timestamp=timestamp)
@@ -225,11 +222,21 @@ def _mxr_frame_factory(hdr:FrameHeader, timestamp:float) -> FrameBase|None:
 
 	# Opcodes reaching here are ones current firmware does not emit:
 	#
+	#   0x16        PDU_STATE               dead; no current MatrixOS build
+	#                                       supports it
 	#   0x17..0x1E  the CEC range           never implemented
-	#   0x25, 0x33  RESERVED_0 / RESERVED_1 retired; never reuse the numbers
+	#   0x25        SYS_BAY_V2IP_DETAILS    retired 2024-09, replaced by 0x3C
 	#   0x2D        VIDEO_CLOCK_RATE_OLD    superseded by clock_rate in 0x31
 	#   0x2E, 0x2F  V2IP_BLIST_*            behind V2IP_SUPPORT_BLACKLIST, which
 	#                                       no project defines
+	#   0x33        RESERVED_1              was MX_OP_NB, the table's end sentinel
+	#
+	# Never reuse 0x16 or 0x25. Both carried a real payload - 0x16 a PDU's state,
+	# 0x25 v2ip_device_sources, with video, audio and anc at 0, 8 and 16,
+	# audio_return at 24 and source_clock at 32 - so a unit old enough to decode
+	# them reads anything reissued under those numbers as the old payload rather
+	# than ignoring it. 0x33 is reserved for a different reason: it was only ever
+	# the table's end marker, so no unit ever read a payload from it.
 	#
 	# Add decoders here rather than removing them: a unit on older firmware still
 	# emits superseded opcodes, which is what 0x06, 0x36 and 0x47 are for. An

mx_remote-5.3.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.3.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.3.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.3.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.1.0 → mx_remote-5.3.0}/mx_remote/remote/Remote.py

@@ -14,10 +14,11 @@ import aiofiles
 import aiohttp
 import os
 from pathlib import Path
+import random
 import time
 
 from .ConnectionAsync import ConnectionAsync
-from ..const import __version__
+from ..const import MXR_HELLO_INTERVAL_MIN, MXR_HELLO_INTERVAL_RAND, __version__
 from .Device import Device
 from ..Interface import ConnectionCallbacks, DeviceRegistry, MxrDeviceUid, BayLinks, BayBase, DeviceBase, MxrCallbacks, AudioEndpoint, mxr_broadcast_address
 from ..proto.Constants import MXR_PROTOCOL_VERSION
@@ -60,7 +61,8 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
         self._callbacks = State(callbacks, http_session)
         self.remotes:dict[MxrDeviceUid,Device] = {}
         self._links = BayLinks(self)
-        self._last_hello = 0
+        self._hello_due = 0.0
+        self._probe_failures = 0
         self._tasks:set[asyncio.Task[None]] = set()
         self._uid:bytes|None = None
         self._uid_path = uid_path
@@ -218,19 +220,56 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
                 return True
         return False
 
+    def _on_task_done(self, task:'asyncio.Task[None]') -> None:
+        '''Drop a finished background task, and report it if something killed it.
+
+        asyncio only surfaces an unretrieved task exception when the task object is
+        garbage collected, which is a different moment and may never come, so a task
+        that dies otherwise does so in silence. Retrieving it here is what makes any
+        future background task fail loudly, including one whose own guard misses.
+        '''
+        self._tasks.discard(task)
+        if task.cancelled():
+            return
+        exc = task.exception()
+        if (exc is not None):
+            _LOGGER.error(f"background task {task.get_name()} died: {exc!r}")
+
     async def _background_probe(self) -> None:
         while not self._closing:
             await asyncio.sleep(1)
-            tx_discover = False
-            if (not self.has_completed_devices()):
-                tx_discover = True
-            else:
-                for _, device in self.remotes.items():
-                    device.check_online()
-                    if not device.check_configuration_complete_timeout():
-                        tx_discover = True
-            if tx_discover and ((time.time() - self._discover_timeout) >= 5):
-                self.tx_discover()
+            try:
+                self._probe_once()
+                self._probe_failures = 0
+            except Exception as e:
+                # A send raises on a closed or unreachable socket. Letting that
+                # escape ends the task, and this loop is the only thing that
+                # announces this client and drives discovery, so one transient
+                # failure would silence it permanently.
+                #
+                # A disconnected interface fails every tick, so only the first
+                # carries a traceback: a full one per second buries everything
+                # else in the log, and the repeats say nothing the first did not.
+                self._probe_failures += 1
+                if (self._probe_failures == 1):
+                    _LOGGER.warning(f"probe failed: {traceback.format_exc()}")
+                else:
+                    _LOGGER.debug(f"probe still failing ({self._probe_failures}): {e!r}")
+
+    def _probe_once(self) -> None:
+        '''One pass of the probe loop: announce if due, then discover if needed.'''
+        if (time.time() >= self._hello_due):
+            self.tx_hello()
+        tx_discover = False
+        if (not self.has_completed_devices()):
+            tx_discover = True
+        else:
+            for _, device in self.remotes.items():
+                device.check_online()
+                if not device.check_configuration_complete_timeout():
+                    tx_discover = True
+        if tx_discover and ((time.time() - self._discover_timeout) >= 5):
+            self.tx_discover()
 
     async def start_async(self) -> None:
         '''Start the server that listens for mx_remote frames from other devices.'''
@@ -240,7 +279,7 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
         await self.conn.start_srv()
         checker = asyncio.create_task(self._background_probe())
         self._tasks.add(checker)
-        checker.add_done_callback(self._tasks.discard)
+        checker.add_done_callback(self._on_task_done)
 
     async def stop_async(self) -> None:
         '''Stop the server and close all connections.'''
@@ -335,14 +374,32 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
         _LOGGER.debug("discovering devices")
         return self.transmit(pkt.frame)
 
+    def _arm_hello(self) -> None:
+        '''Schedule the next announcement, mirroring the firmware's hello timer.
+
+        MatrixOS re-draws min 2.5s + random(0..2.5s) after each hello it sends,
+        so a mesh of devices does not synchronise into bursts. The interval is
+        re-drawn per send rather than fixed for the same reason.
+        '''
+        self._hello_due = time.time() + MXR_HELLO_INTERVAL_MIN \
+            + (random.random() * MXR_HELLO_INTERVAL_RAND)
+
     def tx_hello(self) -> int:
         '''Transmit a hello frame to announce this device on the network.'''
         pkt = constructFrameHello(self)
         if (pkt is None):
             return 0
         _LOGGER.debug("sending hello")
-        self._last_hello = time.time()
-        return self.transmit(pkt.frame)
+        sent = self.transmit(pkt.frame)
+        if (sent > 0):
+            # Only a hello that went out buys the next interval. A send that wrote
+            # nothing leaves _hello_due where it was, so the next probe tick tries
+            # again, which is what firmware does - it resets hello_timeout only in
+            # the success branch of mxr_transmit. Arming here on failure instead
+            # would silence a client for a full interval every time a write failed,
+            # and on an interface that never writes, permanently.
+            self._arm_hello()
+        return sent
 
     def on_connection_made(self) -> None:
         '''Callback invoked after ConnectionAsync has started the server.'''
@@ -374,10 +431,6 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
         timestamp = time.time()
         self.process_frame(timestamp=timestamp, data=data, addr=addr)
 
-        if (self.conn is not None):
-            if (timestamp - self._last_hello >= 30):
-                self.tx_hello()
-
     @override
     def on_mxr_update(self, data:Any) -> None:
         if isinstance(data, FrameHello):

{mx_remote-5.1.0 → mx_remote-5.3.0}/mx_remote/remote/Remote.pyi

@@ -1,7 +1,7 @@
 import aiohttp
 from ..Interface import AudioEndpoint as AudioEndpoint, BayBase as BayBase, BayLinks as BayLinks, ConnectionCallbacks as ConnectionCallbacks, DeviceBase as DeviceBase, DeviceRegistry as DeviceRegistry, MxrCallbacks as MxrCallbacks, mxr_broadcast_address as mxr_broadcast_address
 from ..Uid import MxrDeviceUid as MxrDeviceUid
-from ..const import MX_BCAST_UDP_PORT as MX_BCAST_UDP_PORT, MX_MCAST_UDP_IP as MX_MCAST_UDP_IP, MX_MCAST_UDP_PORT as MX_MCAST_UDP_PORT, __version__ as __version__
+from ..const import MXR_HELLO_INTERVAL_MIN as MXR_HELLO_INTERVAL_MIN, MXR_HELLO_INTERVAL_RAND as MXR_HELLO_INTERVAL_RAND, MX_BCAST_UDP_PORT as MX_BCAST_UDP_PORT, MX_MCAST_UDP_IP as MX_MCAST_UDP_IP, MX_MCAST_UDP_PORT as MX_MCAST_UDP_PORT, __version__ as __version__
 from ..proto.Constants import MXR_PROTOCOL_VERSION as MXR_PROTOCOL_VERSION
 from ..proto.Factory import process_mxr_frame as process_mxr_frame
 from ..proto.FrameDiscover import constructFrameDiscover as constructFrameDiscover

mx_remote-5.3.0/tests/entry.py

@@ -0,0 +1,59 @@
+"""Enter where the runtime enters.
+
+on_datagram_received is what ConnectionAsync calls. process_frame is one level
+below it and is what a test reaches for, because it takes the arguments a test
+already has - so a layer that only the runtime touches goes uncovered while the
+suite looks like it exercises the receive path.
+
+Here that layer re-announces this client's hello. It has one other caller, at
+startup, so if it stopped working the client would announce once and then go
+silent to every peer that started later.
+"""
+import os
+import struct
+import sys
+import time
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import logging
+logging.disable(logging.CRITICAL)
+
+import mx_remote
+from mx_remote.Uid import MxrDeviceUid
+from mx_remote.proto.Factory import create_mxr_frame
+
+UID = bytes(range(1, 17))
+ADDR = ('192.0.2.9', 8812)
+
+class RecordingConn:
+    """Stands in for ConnectionAsync so transmits can be counted."""
+    def __init__(self):
+        self.sent = []
+    def transmit(self, data):
+        self.sent.append(data)
+        return len(data)
+
+def nm(s, sz=16):
+    b = s.encode('ascii')[:sz]
+    return b + bytes(sz - len(b))
+
+HELLO = (struct.pack('<H', 0x28) + nm('MX-1') + nm('P8SN12345678') + nm('4.7.9')
+         + struct.pack('<I', 1 << 5))
+
+mx = mx_remote.Remote(open_connection=False)
+mx._uid = bytes(range(100, 116))
+conn = RecordingConn()
+mx.conn = conn
+
+# a datagram arriving must be decoded, not merely counted
+mx.on_datagram_received(create_mxr_frame(UID, 0x00, HELLO), ADDR)
+assert mx.get_by_uid(MxrDeviceUid(UID)) is not None, 'the datagram was not processed'
+print('entry : a datagram reaching on_datagram_received is decoded')
+
+# Hello timing is not asserted here. It belongs to whatever drives the
+# announcement, and pinning it to a datagram arriving would encode the trigger
+# rather than the behaviour - an assertion that no datagram sends a hello
+# passes trivially once nothing does.
+
+print()
+print('ALL OK')

{mx_remote-5.1.0 → mx_remote-5.3.0}/tests/handlers.py

@@ -32,26 +32,54 @@ import mx_remote.proto as proto_pkg                          # noqa: E402
 from mx_remote.proto.FrameBase import FrameBase              # noqa: E402
 
 BASELINE = {
+    'FrameAmpDolbySettings.FrameAmpDolbySettings',
     'FrameAmpZoneSettings.FrameAmpZoneSettings',
     'FrameAudioClip.FrameAudioClip',
     'FrameAudioSetRoute.FrameAudioSetRoute',
     'FrameBayConfig.FrameBayConfig',
+    'FrameBayConfigSecondary.FrameBayConfigSecondary',
+    'FrameBayHide.FrameBayHide',
     'FrameBayStatus.FrameBayStatus',
+    'FrameConnectStatus.FrameConnectStatus',
+    'FrameDebug.FrameDebug',
+    'FrameFilterStatus.FrameFilterStatus',
     'FrameFirmwareVersion.FrameFirmwareVersion',
     'FrameHello.FrameHello',
     'FrameLinks.FrameLinks',
+    'FrameMeshOperation.FrameMeshOperation',
+    'FrameMirrorStatus.FrameMirrorStatus',
+    'FrameNetworkStatus.FrameNetworkStatus',
+    'FramePowerChange.FramePowerChange',
     'FrameRCAction.FrameRCAction',
     'FrameRCKey.FrameRCKey',
+    'FrameRCSettings.FrameRCSettings',
     'FrameRoutingChange.FrameRoutingChange',
+    'FrameSignalStatus.FrameSignalStatus',
     'FrameSignalStatusNew.FrameSignalStatusNew',
+    'FrameSysTemperature.FrameSysTemperature',
+    'FrameSystemStatus.FrameSystemStatus',
     'FrameTXRCAction.FrameTXRCAction',
     'FrameTXRCKey.FrameTXRCKey',
+    'FrameTopology.FrameTopology',
+    'FrameV2IPAudio.FrameV2IPAudio',
+    'FrameV2IPAudio.FrameV2IPAudioChangeSource',
+    'FrameV2IPAudio.FrameV2IPAudioConfig',
+    'FrameV2IPAudio.FrameV2IPAudioLinks',
+    'FrameV2IPBayMapping.FrameV2IPBayMapping',
     'FrameV2IPDetectBays.FrameV2IPDetectBays',
     'FrameV2IPDeviceConfiguration.FrameV2IPDeviceConfiguration',
+    'FrameV2IPManualSourceSwitch.FrameV2IPManualSourceSwitch',
     'FrameV2IPMultiviewer.FrameV2IPMultiviewer',
+    'FrameV2IPPowerSave.FrameV2IPPowerSave',
+    'FrameV2IPSourceSwitch.FrameV2IPSourceSwitch',
     'FrameV2IPSources.FrameV2IPSources',
     'FrameV2IPStats.FrameV2IPStats',
+    'FrameV2IPTiling.FrameV2IPTiling',
     'FrameV2IPVideoWall.FrameV2IPVideoWall',
+    'FrameVolume.FrameVolume',
+    'FrameVolumeDown.FrameVolumeDown',
+    'FrameVolumeSet.FrameVolumeSet',
+    'FrameVolumeUp.FrameVolumeUp',
 }
 
 def main() -> int: