mx-remote 2.0.0__py3-none-any.whl

mx_remote/remote/Link.py

@@ -0,0 +1,187 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from __future__ import annotations
+from ..proto import LinkConfig
+from ..proto import Constants as proto
+from typing import List, Tuple
+from ..Interface import BayBase, MxrCallbacks
+
+class Link:
+	''' Link between 2 bays on 2 devices '''
+
+	def __init__(self, bay:BayBase, link_data:LinkConfig.LinkConfig):
+		self._bay = bay
+		self._link = link_data
+
+	@property
+	def callbacks(self) -> MxrCallbacks:
+		return self._bay.callbacks
+
+	@property
+	def bays(self) -> List[BayBase]:
+		if self.configured:
+			return [ self._link.remote_bay, self._link.linked_bay ]
+		return [ self._bay ]
+
+	@property
+	def configured(self) -> bool:
+		return (self._link is not None) and self._link.is_linked
+
+	@property
+	def connected(self) -> bool:
+		return self.configured and (self._link.linked_bay is not None)
+
+	@property
+	def online(self) -> bool:
+		return self.connected and (self._link.linked_bay.online)
+
+	@property
+	def primary(self) -> BayBase:
+		# source type bay for linked bays. if only 1 side has been registered, that bay will be returned
+		if not self.connected:
+			return self._bay
+		if self._link.remote_bay.is_input:
+			return self._link.remote_bay
+		return self._link.linked_bay
+
+	def is_primary(self, bay:BayBase) -> bool:
+		# check whether the given bay is the primary bay of this link
+		primary = self.primary
+		return (primary is not None) and (bay == primary)
+
+	def other_bay(self, bay:BayBase) -> BayBase:
+		# return the other side of this link
+		if not self.connected:
+			return None
+		if bay == self._link.linked_bay:
+			return self._link.remote_bay
+		return self._link.linked_bay
+
+	def other_serial_bay(self, bay:BayBase) -> Tuple[str,str]:
+		# return the configuration for the other end of this link (serial + bay)
+		other_bay = self.other_bay(bay)
+		if other_bay is None:
+			return (None, None)
+		return (other_bay.device.serial, other_bay.port)
+
+	def other_serial_bay_str(self, bay:BayBase) -> str:
+		# return the link configuration for the given bay as string
+		link_serial, link_bay = self.other_serial_bay(bay)
+		if (link_serial is None) or (link_bay is None):
+			return ""
+		return f"{link_serial} {link_bay}"
+
+	def serial_bays(self) -> List[str]:
+		# return this link configuration as list of strings
+		rv = []
+		primary = self.primary
+		rv.append(f"{primary.device.serial} {primary.bay_name}")
+		if self.configured:
+			link_serial, link_bay = self.other_serial_bay(primary)
+			rv.append(f"{link_serial} {link_bay}")
+		return rv
+
+	def update(self, config:LinkConfig) -> None:
+		link = Link(config.remote_bay, config)
+		# update this link configuration with the new data from mx_remote
+		if (self.configured and not link.configured) or (self.other_bay(self._bay) != link.other_bay(self._bay)):
+			self.callbacks.on_bay_unlinked(self._bay, self)
+			self.callbacks.on_bay_unlinked(self.other_bay(self._bay), self)
+
+		if (not self.configured and link.configured) or (self.other_bay(self._bay) != link.other_bay(self._bay)):
+			self.callbacks.on_bay_linked(self._bay, link)
+			self.callbacks.on_bay_linked(link.other_bay(self._bay), link)
+		self._link = link._link
+
+	@property
+	def is_audio(self) -> bool:
+		# audio link
+		ft = self.features_mask
+		return (ft & proto.MX_LINK_FEATURE_AUDIO_OPTICAL) != 0 or \
+				(ft & proto.MX_LINK_FEATURE_AUDIO_ANALOG) != 0
+
+	@property
+	def is_video(self) -> bool:
+		# video link
+		return (self.features_mask & proto.MX_LINK_FEATURE_VIDEO_HDMI) != 0
+
+	@property
+	def features(self) -> List[str]:
+		# features supported by this link (strings)
+		ft = []
+		m = self.features_mask
+		if (m & proto.MX_LINK_FEATURE_VIDEO_HDMI):
+			ft.append("HDMI")
+		if (m & proto.MX_LINK_FEATURE_AUDIO_OPTICAL):
+			ft.append("optical audio")
+		if (m & proto.MX_LINK_FEATURE_AUDIO_ANALOG):
+			ft.append("analog audio")
+		if (m & proto.MX_LINK_FEATURE_IR):
+			ft.append("IR")
+		if (m & proto.MX_LINK_FEATURE_RC):
+			ft.append("RC")
+		return ft
+
+	@property
+	def features_mask(self) -> int:
+		# features supported by this link (bitmask)
+		bays = self.bays
+		if len(bays) < 2:
+			return 0
+		left = bays[0].features_mask
+		right = bays[1].features_mask
+		rv = 0
+		if (left & proto.MX_BAY_FEATURE_HDMI_OUT):
+			if (right & proto.MX_BAY_FEATURE_HDMI_IN):
+				rv |= proto.MX_LINK_FEATURE_VIDEO_HDMI
+		if (left & proto.MX_BAY_FEATURE_HDMI_IN):
+			if (right & proto.MX_BAY_FEATURE_HDMI_OUT):
+				rv |= proto.MX_LINK_FEATURE_VIDEO_HDMI
+		if (left & proto.MX_BAY_FEATURE_AUDIO_DIG_OUT):
+			if (right & proto.MX_BAY_FEATURE_AUDIO_DIG_IN):
+				rv |= proto.MX_LINK_FEATURE_AUDIO_OPTICAL
+		if (left & proto.MX_BAY_FEATURE_AUDIO_DIG_IN):
+			if (right & proto.MX_BAY_FEATURE_AUDIO_DIG_OUT):
+				rv |= proto.MX_LINK_FEATURE_AUDIO_OPTICAL
+		if (left & proto.MX_BAY_FEATURE_AUDIO_ANA_OUT):
+			if (right & proto.MX_BAY_FEATURE_AUDIO_ANA_IN):
+				rv |= proto.MX_LINK_FEATURE_AUDIO_ANALOG
+		if (left & proto.MX_BAY_FEATURE_AUDIO_ANA_IN):
+			if (right & proto.MX_BAY_FEATURE_AUDIO_ANA_OUT):
+				rv |= proto.MX_LINK_FEATURE_AUDIO_ANALOG
+		if (left & proto.MX_BAY_FEATURE_IR_OUT):
+			if (right & proto.MX_BAY_FEATURE_IR_IN):
+				rv |= proto.MX_LINK_FEATURE_IR
+		if (left & proto.MX_BAY_FEATURE_IR_IN):
+			if (right & proto.MX_BAY_FEATURE_IR_OUT):
+				rv |= proto.MX_LINK_FEATURE_IR
+		if (left & proto.MX_BAY_FEATURE_RC_OUT):
+			if (right & proto.MX_BAY_FEATURE_RC_IN):
+				rv |= proto.MX_LINK_FEATURE_RC
+		if (left & proto.MX_BAY_FEATURE_RC_IN):
+			if (right & proto.MX_BAY_FEATURE_RC_OUT):
+				rv |= proto.MX_LINK_FEATURE_RC
+		return rv
+
+	def __eq__(self, other:Link) -> bool:
+		return (self.configured == other.configured) and \
+			(((self._bay == other._bay) and (self.other_bay(self._bay) == other.other_bay(self._bay))) or \
+				((self.other_bay(self._bay) == other._bay) and (self._bay == other.other_bay(self._bay))))
+
+	def __str__(self) -> str:
+		primary = self.primary
+		if primary is None:
+			return "bay link incomplete"
+		if not self.configured:
+			return "{} not linked".format(str(primary))
+		other = self.other_bay(primary)
+		if other is None:
+			link_serial, link_bay = self.other_serial_bay(primary)
+			return "{} linked to ({} {}) - disconnected".format(str(primary), link_serial, link_bay)
+		return "{} linked to {} - {}".format(str(primary), str(other), str(self.features))
+

mx_remote/remote/PDU.py

@@ -0,0 +1,152 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from ..proto.PDUState import PDUState
+from typing import Any, List
+
+class PDUOutlet:
+    ''' One of the 8 PDU outlets '''
+
+    def __init__(self, pdu: Any, port: int, state: PDUState):
+        self._pdu = pdu
+        self._port = port
+        self._state = state
+
+    @property
+    def port(self) -> int:
+        # port number
+        return self._port
+
+    @property
+    def state(self) -> PDUState:
+        return self._state
+
+    @state.setter
+    def state(self, val: PDUState):
+        self._state = val
+
+    @property
+    def is_on(self) -> bool:
+        return self._state.is_on
+
+    @property
+    def is_off(self) -> bool:
+        return self._state.is_off
+
+    @property
+    def is_rebooting(self) -> bool:
+        return self._state.is_rebooting
+
+    async def turn_on(self):
+        return await self._pdu.dev.get_api('power/on/{}'.format(self.port))
+
+    async def turn_off(self):
+        return await self._pdu.dev.get_api('power/off/{}'.format(self.port))
+
+    def __str__(self) -> str:
+        return str(self._state)
+
+    def __repr__(self) -> str:
+        return "{}={}".format(str(self._port), str(self))
+
+class PDU:
+    ''' Optional PDU connected to a matrix '''
+    def __init__(self, dev, init_val:PDUState):
+        self._dev = dev
+        self._val = None
+        self._outlets = []
+        self.on_mxr_update(init_val)
+
+    @property
+    def dev(self):
+        return self._dev
+
+    @property
+    def mxr(self) -> Any:
+        # mxremote instance
+        return self._dev.mxr
+
+    @property
+    def connected(self) -> bool:
+        voltage = self.voltage
+        return (voltage is not None) and (voltage > 0.0)
+
+    @property
+    def current(self) -> float:
+        if self._val is None:
+            return None
+        return self._val.current
+
+    @property
+    def voltage(self) -> float:
+        if self._val is None:
+            return None
+        return self._val.voltage
+
+    @property
+    def power(self) -> float:
+        if self._val is None:
+            return None
+        return self._val.power
+
+    @property
+    def dissipation(self) -> float:
+        if self._val is None:
+            return None
+        return self._val.dissipation
+
+    @property
+    def power_factor(self) -> float:
+        if self._val is None:
+            return None
+        return self._val.power_factor
+
+    @property
+    def frequency(self) -> float:
+        if self._val is None:
+            return None
+        return self._val.frequency
+
+    @property
+    def outlets(self) -> List[PDUOutlet]:
+        if self._val is None:
+            return None
+        return self._outlets
+
+    def outlet(self, port) -> PDUOutlet:
+        if self._val is None:
+            return None
+        return self._outlets[port]
+
+    def on_mxr_update(self, pdu_state:PDUState) -> None:
+        changed = self._val is None or (self._val != pdu_state)
+        is_new = (len(self._outlets) == 0)
+        self._val = pdu_state
+        port = 0
+        for outlet in pdu_state.outlets:
+            if is_new:
+                self._outlets.append(PDUOutlet(self, port, outlet))
+            else:
+                self._outlets[port].state = outlet
+            port = port + 1
+        if changed and not is_new:
+            # tell callbacks that this device changed
+            self.mxr.on_pdu_changed(self)
+
+    def __str__(self) -> str:
+        return "current = {}A, voltage = {}V, power = {}W, diss = {}W, freq = {}Hz, outlets = {}".format(str(self.current), str(self.voltage), str(self.power), str(self.dissipation), str(self.frequency), str(self.outlets))
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __eq__(self, other) -> bool:
+        return isinstance(other, PDU) and \
+            (self.dev == other.dev)
+
+    def __ne__(self, other) -> bool:
+        return (not isinstance(other, PDU)) or \
+            (self.dev != other.dev)

mx_remote/remote/Remote.py

@@ -0,0 +1,300 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+import logging
+import asyncio
+import aiofiles
+import aiohttp
+import os
+from pathlib import Path
+import time
+
+from .ConnectionAsync import ConnectionAsync
+from ..const import __version__
+from .Device import Device
+from ..Interface import ConnectionCallbacks, DeviceRegistry, MxrDeviceUid, BayLinks, BayBase, DeviceBase, MxrCallbacks
+from ..proto.Constants import MXR_PROTOCOL_VERSION
+from ..proto.FrameDiscover import FrameDiscover
+from ..proto.Factory import process_mxr_frame
+from ..proto.FrameBase import FrameBase
+from ..proto.FrameHello import FrameHello
+from ..Uid import MxrDeviceUid
+from .State import State
+
+import traceback
+
+from ..const import MX_BCAST_UDP_IP, MX_BCAST_UDP_PORT, MX_MCAST_UDP_IP, MX_MCAST_UDP_PORT
+
+_LOGGER = logging.getLogger(__name__)
+
+class Remote(DeviceRegistry, ConnectionCallbacks):
+    ''' Main component that handles the network connections and registration of remote devices '''
+
+    def __init__(self, target_ip:str|None=None, port:int|None=None, http_session:aiohttp.ClientSession|None=None, open_connection:bool=True, callbacks:MxrCallbacks|None=None, name:str="MXR Python", local_ip:str|None=None, broadcast:bool|None=None) -> None:
+        DeviceRegistry.__init__(self)
+        ConnectionCallbacks.__init__(self)
+        self._name = name
+        self._close_session = False
+        self._http_session = None
+        self._callbacks = State(callbacks, http_session)
+        self.remotes:dict[MxrDeviceUid,Device] = {}
+        self._links = BayLinks(self)
+        self._last_hello = 0
+        self._tasks = set()
+        self._uid:bytes|None = None
+        self._local_ip = local_ip
+        self._broadcast = broadcast
+        self._target_ip = target_ip
+        self._port = port
+        self._discover_timeout = 0
+        if open_connection:
+            self.conn = ConnectionAsync(callbacks=self, target_ip=self.target_ip, port=self.port, local_ip=self._local_ip)
+        else:
+            self.conn = None
+
+    @property
+    def library_version(self) -> str:
+        ''' version of the mx_remote library '''
+        return __version__
+
+    @property
+    def protocol_version(self) -> int:
+        ''' protocol version used by this library '''
+        return MXR_PROTOCOL_VERSION
+
+    @property
+    def net_protocol_version_max(self) -> int:
+        ''' highest protocol version used by devices on the network '''
+        proto = 0
+        for _, device in self.remotes.items():
+            if (device.protocol > proto):
+                proto = device.protocol
+        return proto
+
+    @property
+    def net_protocol_version_min(self) -> int:
+        ''' lowest protocol version used by devices on the network '''
+        proto = MXR_PROTOCOL_VERSION
+        for _, device in self.remotes.items():
+            if (device.protocol < proto):
+                proto = device.protocol
+        return proto
+
+    @property
+    def target_ip(self):
+        if self._target_ip is None:
+            return MX_MCAST_UDP_IP if (self._broadcast is None or not self._broadcast) else MX_BCAST_UDP_IP
+        return self._target_ip
+
+    @property
+    def local_ip(self) -> str:
+        return self._local_ip
+
+    @property
+    def broadcast(self) -> bool:
+        return ((self._broadcast is not None) and self._broadcast)
+
+    @property
+    def port(self):
+        if self._port is None:
+            return MX_MCAST_UDP_PORT if (self._broadcast is None or not self._broadcast) else MX_BCAST_UDP_PORT
+        return self._port
+
+    async def _load_uid(self) -> None:
+        if self._uid is not None:
+            return
+        uid_path = Path.home().joinpath(".mxr-uid")
+        try:
+            async with aiofiles.open(uid_path, "rb") as f:
+                self._uid = await f.read()
+        except:
+            _LOGGER.info(f"failed to read {uid_path}. creating new file")
+            self._uid = os.urandom(16)
+            async with aiofiles.open(uid_path, "wb") as f:
+                await f.write(self._uid)
+
+    @property
+    def uid_raw(self) -> bytes:
+        return self._uid
+
+    @property
+    def uid(self) -> MxrDeviceUid:
+        return MxrDeviceUid(self.uid_raw)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def callbacks(self) -> MxrCallbacks:
+        return self._callbacks.callbacks
+
+    @property
+    def http_session(self) -> aiohttp.ClientSession:
+        ''' Active HTTP client session for API commands '''
+        return self._callbacks.http_session
+
+    async def update_config(self, callbacks:MxrCallbacks|None=None, name:str|None=None, target_ip:str|None=None, port:int|None=None, local_ip:str|None=None, broadcast:bool|None=None):
+        if (callbacks is not None):
+            self._callbacks = callbacks
+        if (name is not None):
+            self._name = name
+        if (target_ip is not None) or (port is not None) or (local_ip is not None) or (broadcast is not None):
+            changed = False
+            if (target_ip is not None) and (self._target_ip != target_ip):
+                _LOGGER.debug(f"updating target ip to {target_ip}")
+                self._target_ip = target_ip
+                changed = True
+            if (port is not None) and (self._port != port):
+                _LOGGER.debug(f"updating target port to {port}")
+                self._port = port
+                changed = True
+            if (local_ip is not None) and (self._local_ip != local_ip):
+                _LOGGER.debug(f"updating target ip to {local_ip}")
+                self._local_ip = local_ip
+                changed = True
+            if (broadcast is not None) and (self._broadcast != broadcast):
+                _LOGGER.debug(f"updating target ip to {broadcast}")
+                self._broadcast = broadcast
+                changed = True
+            if changed:
+                if (self.conn is not None):
+                    _LOGGER.debug(f"closing connection")
+                    self.conn.close()
+                _LOGGER.debug(f"opening new mx_remote listener on target={self.target_ip} listener={self._local_ip}:{self.port}")
+                self.conn = ConnectionAsync(callbacks=self, target_ip=self.target_ip, port=self.port, local_ip=self._local_ip)
+                await self.conn.start_srv()
+
+    def has_completed_devices(self) -> bool:
+        for _, device in self.remotes.items():
+            if device.configuration_complete:
+                return True
+        return False
+
+    async def _background_probe(self) -> None:
+        while not self._close_session:
+            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()
+
+    async def start_async(self) -> None:
+        # start the server that listens for mx_remote frames from other devices
+        await self._load_uid()
+        await self.conn.start_srv()
+        checker = asyncio.create_task(self._background_probe())
+        self._tasks.add(checker)
+        checker.add_done_callback(self._tasks.discard)
+
+    async def close(self) -> None:
+        # close all open connections
+        _LOGGER.debug("closing mx_remote listener")
+        if self.conn is not None:
+            self.conn.close()
+        if self._close_session:
+            await self.http_session.close()
+
+    def get_by_serial(self, serial:str) -> DeviceBase|None:
+        # get the local cache for a device, given it's serial number
+        for _, remote in self.remotes.items():
+            if serial == remote.serial:
+                return remote
+        return None
+
+    def get_by_uid(self, remote_id:str|MxrDeviceUid) -> DeviceBase|None:
+        # get the local cache for a device, given it's unique id
+        remote_id = MxrDeviceUid(remote_id)
+        if remote_id in self.remotes.keys():
+            return self.remotes[remote_id]
+        if isinstance(remote_id, str):
+            return self.get_by_serial(serial=remote_id)
+        return None
+
+    def get_by_stream_ip(self, ip:str, audio:bool=False) -> BayBase|None:
+        for _, dev in self.remotes.items():
+            if not dev.is_v2ip or dev.v2ip_sources is None or dev.first_input is None:
+                continue
+            if not audio and (dev.first_input.v2ip_source.video.ip == ip):
+                return dev.first_input
+            if audio and (dev.first_input.v2ip_source.audio.ip == ip):
+                return dev.first_input
+        return None
+    
+    def get_bay_by_portnum(self, remote_id:str|MxrDeviceUid, portnum:int) -> BayBase|None:
+        # get the local cache for a bay, given the device's unique id and port number
+        device = self.get_by_uid(remote_id=remote_id) if isinstance(remote_id, MxrDeviceUid) else self.get_by_serial(serial=remote_id)
+        if device is None:
+            return None
+        return device.get_by_portnum(portnum)
+
+    def get_bay_by_portname(self, remote_id:str|MxrDeviceUid, portname:str) -> BayBase|None:
+        device = self.get_by_uid(remote_id=remote_id) if isinstance(remote_id, MxrDeviceUid) else self.get_by_serial(serial=remote_id)
+        if device is None:
+            return None
+        return device.get_by_portname(portname=portname)
+
+    @property
+    def links(self) -> BayLinks:
+        return self._links
+
+    def transmit(self, data: bytes) -> int:
+        return self.conn.transmit(data=data)
+
+    def tx_discover(self) -> int:
+        # transmit a discover frame. all remotes will send a hello frame as response
+        pkt:FrameBase = FrameDiscover.construct(self)
+        self._discover_timeout = time.time()
+        _LOGGER.debug("discovering devices")
+        return self.transmit(pkt.frame)
+
+    def tx_hello(self):
+        pkt:FrameBase = FrameHello.construct(self)
+        _LOGGER.debug("sending hello")
+        self._last_hello = time.time()
+        return self.transmit(pkt.frame)
+
+    def on_connection_made(self) -> None:
+        # callback called after the server got started by ConnectionAsync
+        self.tx_discover()
+        self.tx_hello()
+
+    def on_datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
+        # called when a udp frame was received
+        try:
+            frame = process_mxr_frame(self, data, addr)
+            if frame is not None:
+                _LOGGER.debug(f"rx {addr[0]}: {frame.header.opcode:02X}({len(frame)}) - {str(frame)}")
+        except Exception as e:
+            _LOGGER.warning(f"failed to decode frame {traceback.format_exc()}")
+            raise
+        try:
+            if frame is not None:
+                frame.process()
+        except Exception as e:
+            _LOGGER.warning(f"failed to process frame: {traceback.format_exc()}")
+            raise
+
+        if self.conn is not None:
+            now = time.time()
+            if (now - self._last_hello >= 30):
+                self.tx_hello()
+
+    def on_mxr_hello(self, hello_frame:FrameHello) -> Device:
+        # hello frame received. register or update the local device cache
+        d = self.get_by_uid(hello_frame.remote_id)
+        if d is None:
+            d = Device(self, hello_frame)
+            self.remotes[hello_frame.remote_id] = d
+        d.on_mxr_hello(hello_frame)
+        return d

mx_remote/remote/State.py

@@ -0,0 +1,28 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from ..Interface import MxrCallbacks
+import aiohttp
+
+class State:
+    def __init__(self, callbacks:MxrCallbacks|None=None, http_session:aiohttp.ClientSession|None=None) -> None:
+        if callbacks is None:
+            self._callbacks = MxrCallbacks()
+        else:
+            self._callbacks = callbacks
+        self._close_session = (http_session is not None)
+        self._http_session = http_session
+
+    @property
+    def http_session(self) -> aiohttp.ClientSession:
+        if self._http_session is None:
+            self._http_session = aiohttp.ClientSession()
+        return self._http_session
+
+    @property
+    def callbacks(self) -> MxrCallbacks:
+        return self._callbacks