mx-remote 2.0.0__py3-none-any.whl

mx_remote/Uid.py

@@ -0,0 +1,137 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+import logging
+import json
+_LOGGER = logging.getLogger(__name__)
+class MxrDeviceUid:
+    ''' Unique ID of an mx_remote device on the network'''
+
+    def __init__(self, value: object) -> None:
+        if isinstance(value, MxrDeviceUid):
+            self._value = value._value
+            return
+        if isinstance(value, str):
+            spl = value.split(".")
+            if len(spl) < 4:
+                raise Exception(f"invalid uid {value}")
+            self._value = []
+            for part in spl:
+                self._value += int(part, 16).to_bytes(4, 'little')
+            self._value = bytes(self._value)
+        elif isinstance(value, bytes):
+            if len(value) == 0:
+                self._value = None
+            elif len(value) < 16:
+                raise Exception(f"invalid uid length {len(value)}")
+            else:
+                self._value = value
+        else:
+            raise Exception(f"invalid uid type {str(type(value))}")
+
+    def toJson(self):
+        return json.dumps(self, default=lambda o: o.__dict__)
+
+    @property
+    def value(self) -> str:
+        ''' value as human readble string '''
+        return ''.join('%02x'%i for i in reversed(self._value[0:4])) + '.' + \
+            ''.join('%02x'%i for i in reversed(self._value[4:8])) + '.' + \
+            ''.join('%02x'%i for i in reversed(self._value[8:12])) + '.' + \
+            ''.join('%02x'%i for i in reversed(self._value[12:16]))
+
+    @property
+    def empty(self) -> bool:
+        ''' True if all 0 '''
+        for v in self._value:
+            if int(v) != 0:
+                return False
+        return True
+
+    @property
+    def byte_value(self) -> bytes:
+        ''' value as bytes '''
+        return self._value
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+    def __eq__(self, value: object) -> bool:
+        if isinstance(value, str) or isinstance(value, MxrDeviceUid):
+            return str(self) == str(value)
+        return False
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+class MxrBayUidOld:
+    def __init__(self, serial:str, port_name:str) -> None:
+        self._serial = serial
+        self._port_name = port_name
+
+    @property
+    def serial(self) -> str:
+        return self._serial
+
+    @property
+    def port_name(self) -> str:
+        return self._port_name
+
+    @property
+    def empty(self) -> bool:
+        return (len(self.serial) == 0) or (len(self.port_name) == 0)
+
+    def __str__(self) -> str:
+        return f"{self.serial}:{self.port_name}"
+
+    def __eq__(self, value: object) -> bool:
+        if isinstance(value, str):
+            return (str(self) == value)
+        if isinstance(value, MxrBayUidOld):
+            return (self.serial == value.serial) and (self.port_name == value.port_name)
+        return False
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+class MxrBayUid:
+    def __init__(self, device:MxrDeviceUid, port_number:int) -> None:
+        self._device = device
+        self._port = port_number
+
+    @property
+    def device(self) -> MxrDeviceUid:
+        return self._device
+
+    @property
+    def port(self) -> int:
+        return self._port
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __str__(self) -> str:
+        return f"{str(self.device)}:{self.port}"
+
+    def __repr__(self) -> str:
+        return str(self)    
+
+    def __eq__(self, value: object) -> bool:
+        if isinstance(value, str):
+            return (str(self) == value)
+        if not isinstance(value, MxrBayUid):
+            return False
+        return (self.device == value.device) and (self.port == value.port)
+
+    def __hash__(self) -> int:
+        return hash(str(self))

mx_remote/__init__.py

@@ -0,0 +1,12 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .remote.Remote import Remote
+from .Interface import *
+from .const import VERSION
+from .proto.Constants import MXR_PROTOCOL_VERSION
+from .main import mxr_console, mxr_main, proto_parser

mx_remote/api/BayConfig.py

@@ -0,0 +1,53 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+class BayConfig:
+    ''' Bay details from the api '''
+    def __init__(self, bay):
+        self.bay = bay
+        self._data = None
+
+    @property
+    def name(self) -> str:
+        if (self._data is None) or ('Name' not in self._data.keys()):
+            return None
+        return self._data['Name']
+
+    @property
+    def bay_type(self) -> str:
+        if (self._data is None) or ('Name' not in self._data.keys()):
+            return "Unknown"
+        return self._data['Type']
+
+    @property
+    def status(self) -> int:
+        if (self._data is None) or ('Status' not in self._data.keys()):
+            return -1
+        return int(self._data['Status'])
+
+    @property
+    def hidden(self) -> bool:
+        return (self._data is not None) and ('Hidden' in self._data.keys()) and (self._data['Hidden'])
+
+    @property
+    def is_hdmi(self) -> bool:
+        return (self.bay_type[0:4] == 'HDMI')
+
+    @property
+    def is_hdbt(self) -> bool:
+        return (self.bay_type[0:4] == 'HDBT')
+
+    @property
+    def is_audio(self) -> bool:
+        return (self.bay_type[0:5] == 'AUDIO')
+
+    @property
+    def cec_version(self) -> int:
+        if (self._data is None) or ('CEC_version' not in self._data.keys()):
+            return None
+        return int(self._data['CEC_version'])
+

mx_remote/api/__init__.py

@@ -0,0 +1,8 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from .BayConfig import BayConfig

mx_remote/const.py

@@ -0,0 +1,20 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+""" constant definitions for mx_remote """
+import os
+
+VERSION = '2.0.0'
+__version__ = VERSION
+
+MX_BCAST_UDP_IP = '10.8.8.255'
+MX_BCAST_UDP_PORT = 8811
+
+MX_MCAST_UDP_IP = '224.8.8.8'
+MX_MCAST_UDP_PORT = 8812
+
+BASE_PATH = os.path.dirname(__file__)

mx_remote/main.py

@@ -0,0 +1,117 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+import argparse
+import asyncio
+import logging
+import mx_remote
+import os
+from typing import Any
+
+_LOGGER = logging.getLogger(__name__)
+
+# import pdb_attach
+# pdb_attach.listen(50000)
+
+def proto_parser(logger:logging.Logger, file:str, filter:str|None) -> None:
+    """
+    protocol parser entry point
+
+    Process a file captured by MatrixOS or Wireshark
+
+    Args:
+        logger (logging.Logger): logger to use to output processed data from the capture file
+        file (str): path to the file to process
+        filter (str): IP address filter (optional)
+    """
+    if os.path.isfile(file):
+        raise Exception(f"cannot find '{file}'")
+
+    with open(file, "r") as f:
+        data = f.read().split("\n")
+        remote = mx_remote.Remote(open_connection=False)
+        logger.debug(f"processing data from {file}")
+        for line in data:
+            spl = line.split(",")
+            if len(spl) == 3:
+                ts = spl[0]
+                source = spl[1]
+                if filter is not None and source != filter:
+                    continue
+                frame = bytes.fromhex(spl[2])
+                try:
+                    logger.debug(f"[[frame {ts}]]")
+                    remote.on_datagram_received(frame, (source, 8811))
+                except Exception as e:
+                    logger.warning(f"source: {source}    frame FAILED: {e}")
+
+def mxr_main( extra_args_callback:callable=None,
+              log_level_callback:callable=None,
+              entry_callback:callable=None,
+              callback_param:Any=None) -> None:
+    """
+    mx_remote main entry point for stand alone applications
+
+    Args:
+        extra_args_callback (callable): callback to add extra arguments into the arguments parser
+        log_level_callback (callable): callback to set the default logging level
+        entry_callback (callable): callback to override the main entry point of the application
+        callback_param (Any): parameter passed to callbacks
+    """
+
+    # command line arguments
+    argparser = argparse.ArgumentParser(description="MX Remote Manager / Debugger")
+    argparser.add_argument("-i", dest='input', help='capture file to process', required=False)
+    argparser.add_argument("-f", dest='filter', help='ip address to process in the capture file', required=False)
+    argparser.add_argument("-o", dest='output', help='write output to a file', required=False)
+    argparser.add_argument("-l", dest='local_ip', help='local ip address of the network interface to use', required=False)
+    argparser.add_argument("-b", dest='broadcast', help='use broadcast mode instead of multicast mode', required=False, type=bool)
+    if (extra_args_callback is not None):
+        extra_args_callback(callback_param, argparser)
+    args = argparser.parse_args()
+
+    if (log_level_callback is not None):
+        default_level = log_level_callback(callback_param, args)
+    else:
+        default_level = logging.DEBUG
+
+    # log output
+    if (args.output is None):
+        # console
+        logging.basicConfig(level=default_level, format='%(asctime)s [%(levelname)s] %(message)s', force=True)
+    else:
+        # file
+        logging.basicConfig(
+            level=default_level,
+            format="%(asctime)s - %(message)s",
+            datefmt='%d-%b-%y %H:%M:%S',
+            force=True,
+            handlers=[
+                logging.FileHandler(args.output),
+                logging.StreamHandler()
+            ])
+
+    if (args.input is not None):
+        proto_parser(_LOGGER, args.input, args.filter)
+    else:
+        if (entry_callback is not None) and entry_callback(callback_param, args):
+            # handled externally
+            return
+
+        # run the console app
+        loop = asyncio.get_event_loop()
+        try:
+            mx = mx_remote.Remote(local_ip=args.local_ip, broadcast=(args.broadcast is not None and args.broadcast))
+            loop.run_until_complete(mx.start_async())
+            loop.run_forever()
+        except KeyboardInterrupt:
+            pass
+        loop.run_until_complete(mx.close())
+        loop.close()
+
+def mxr_console() -> None:
+    mxr_main()

mx_remote/proto/BayConfig.py

@@ -0,0 +1,104 @@
+##################################################
+##         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 .Constants import BayStatusMask
+import struct
+
+class BayConfig:
+	''' Bay configuration for a remote device '''
+	def __init__(self, payload:bytes):
+		self.payload = payload
+
+	@property
+	def port(self) -> int:
+		# port number
+		return int(self.payload[0])
+
+	@property
+	def modenum(self) -> int:
+		# port mode number
+		return int(self.payload[1])
+
+	@property
+	def mode(self) -> str:
+		# port mode
+		nb = self.modenum
+		if nb == 0:
+			return 'Input'
+		if nb == 1:
+			return 'Output'
+		return 'Unknown'
+
+	@property
+	def is_input(self) -> bool:
+		# input bay
+		return self.modenum == 0
+
+	@property
+	def is_output(self) -> bool:
+		# output bay
+		return self.modenum == 1
+
+	@property
+	def bay(self) -> int:
+		# bay number
+		return int(self.payload[2])
+
+	@property
+	def video_source(self) -> int:
+		# video source bay number
+		return int(self.payload[3])
+
+	@property
+	def edid_profile(self) -> int:
+		return ((int(self.payload[4]) & 0xF) << 8) | int(self.payload[3])
+
+	@property
+	def rc_type(self) -> int:
+		return ((int(self.payload[4]) > 4) & 0xF)
+
+	@property
+	def audio_source(self) -> int:
+		# audio source bay number
+		return int(self.payload[4])
+
+	@property
+	def bay_name(self) -> str:
+		# bay name
+		return self.payload[5:21].split(b'\0',1)[0].decode('ascii')
+
+	@property
+	def user_name(self) -> str:
+		# user set name
+		return self.payload[21:37].split(b'\0',1)[0].decode('ascii')
+
+	@property
+	def signal_type(self) -> str:
+		# video signal type
+		return self.payload[37:53].split(b'\0',1)[0].decode('ascii')
+
+	@property
+	def status(self) -> BayStatusMask:
+		# bay status
+		return BayStatusMask(struct.unpack('<L', self.payload[53:57])[0])
+
+	@property
+	def features(self) -> int:
+		# features mask
+		return struct.unpack('<L', self.payload[57:61])[0]
+
+	def __str__(self) -> str:
+		return f"{self.mode} {self.bay + 1} (port {self.port}): {self.user_name} - {self.signal_type}"
+
+	def bay_match(self, other: BayConfig) -> bool:
+		# check whether other is a configuration for the same bay as this one
+		return (self.port == other.port) and \
+				(self.modenum == other.modenum) and \
+				(self.bay == other.bay) and \
+				(self.features == other.features)
+