moved everything to a new module called backend

backend/recorder_adapters/__init__.py

@@ -0,0 +1,136 @@
+import inspect
+import pkgutil
+import sys
+import telnetlib
+from abc import ABC, abstractmethod
+
+# monkey patching of telnet lib
+original_read_until = telnetlib.Telnet.read_until
+original_write = telnetlib.Telnet.write
+
+
+def new_read_until(self, match, timeout=None):
+    if isinstance(match, str):
+        return original_read_until(self, match.encode("ascii"), timeout)
+    else:
+        return original_read_until(self, match, timeout)
+
+
+def new_write(self, buffer):
+    if isinstance(buffer, str):
+        return original_write(self, buffer.encode("ascii"))
+    else:
+        return original_write(self, buffer)
+
+
+telnetlib.Telnet.read_until = new_read_until
+telnetlib.Telnet.write = new_write
+
+
+def read_line(self, timeout=2):
+    return self.read_until("\n", timeout)
+
+
+telnetlib.Telnet.read_line = read_line
+
+
+def read_until_non_empty_line(self):
+    line = self.read_line()
+    if line is None:
+        return None
+    while len(line.rstrip()) <= 0:
+        line = self.read_line()
+    return line
+
+
+telnetlib.Telnet.read_until_non_empty_line = read_until_non_empty_line
+
+
+def assert_string_in_output(self, string, timeout=2):
+    resp = self.read_until(string, timeout)
+    if resp is None:
+        return False, resp,
+    resp = resp.decode("ascii")
+    if string in resp:
+        return True, resp
+    return False, resp
+
+
+telnetlib.Telnet.assert_string_in_output = assert_string_in_output
+
+
+class TelnetAdapter(ABC):
+    def __init__(self, address, esc_char="W"):
+        self.address = address
+        self.tn = None
+        self.esc_char = esc_char
+
+    @abstractmethod
+    def _login(self):
+        pass
+
+    def _run_cmd(self, cmd, timeout=1, auto_connect=True):
+        if self.tn is None and not auto_connect:
+            raise Exception("Not connected!")
+        elif self.tn is None:
+            self._login()
+        self.tn.write(cmd)
+        out = self.tn.read_until_non_empty_line()
+        res = out
+        while out is not None and out != "":
+            out = self.tn.read_until_non_empty_line()
+            print(out)
+            res += out
+        return res
+
+    @staticmethod
+    def _get_response_str(tn_response):
+        if isinstance(tn_response, bytes):
+            return str(tn_response.decode("ascii").rstrip())
+        else:
+            return str(tn_response).rstrip()
+
+
+class RecorderAdapter:
+    @abstractmethod
+    def _get_name(self):
+        pass
+
+    @abstractmethod
+    def _get_version(self):
+        pass
+
+
+def get_defined_recorder_adapters():
+    models = []
+    found_packages = list(pkgutil.iter_modules(sys.modules[__name__].__path__))
+    for f_p in found_packages:
+        importer = f_p[0]
+        rec_model_module = importer.find_module(f_p[1]).load_module(f_p[1])
+        rec_model = {'id': f_p[1], 'name': f_p[1], 'commands': {}}
+        if hasattr(rec_model_module, 'RECORDER_MODEL_NAME'):
+            rec_model['name'] = rec_model_module.RECORDER_MODEL_NAME
+        if hasattr(rec_model_module, 'REQUIRES_USER'):
+            rec_model['requires_user'] = rec_model_module.REQUIRES_USER
+        if hasattr(rec_model_module, 'REQUIRES_PW'):
+            rec_model['requires_password'] = rec_model_module.REQUIRES_PW
+        for name, obj in inspect.getmembers(rec_model_module, inspect.isclass):
+            if issubclass(obj, RecorderAdapter):
+                commands = {}
+                for method_name, method in inspect.getmembers(obj, predicate=inspect.isfunction):
+                    if len(method_name) > 0 and "_" == method_name[0]:
+                        continue
+                    signature = inspect.signature(method)
+                    parameters = {}
+                    for params in signature.parameters:
+                        if params == "self":
+                            continue
+                        param_type = signature.parameters[params].annotation.__name__
+                        param_type = "_unknown_type" if param_type == "_empty" else param_type
+                        parameters[signature.parameters[params].name] = param_type
+                    if len(parameters) <= 0:
+                        parameters = None
+                    commands[method_name] = parameters
+                rec_model["commands"] = commands
+        models.append(rec_model)
+    return models

backend/recorder_adapters/extron_smp.py

@@ -0,0 +1,786 @@
+from backend.recorder_adapters import telnetlib, TelnetAdapter, RecorderAdapter
+
+RECORDER_MODEL_NAME = "SMP 351 / 352"
+VERSION = "0.9.0"
+REQUIRES_USER = False
+REQUIRES_PW = True
+
+# HOST = "localhost"
+# HOST = "129.13.51.102"  # Audimax SMP 351
+# HOST = "129.13.51.106"  # Tulla SMP 351
+HOST = "172.22.246.207"  # Test SMP MZ
+
+USER = "admin"
+PW = "123mzsmp"
+
+
+class SMP(TelnetAdapter, RecorderAdapter):
+    def __init__(self, address, password, **kwargs):
+        super().__init__(address)
+        self.admin_pw = password
+
+    def _login(self):
+        self.tn = telnetlib.Telnet(HOST)
+        self.tn.read_until("\r\nPassword:")
+        # password = getpass.getpass()
+        password = self.admin_pw
+        self.tn.write(password + "\n\r")
+
+        out = self.tn.assert_string_in_output("Login Administrator")
+        if not out[0]:
+            print(out[1])
+            if "Password:" in out[1]:
+                # TODO: loop until logged in...
+                print("re-enter pw")
+                self.tn.write("123mzsmp\n\r")
+                print(self.tn.assert_string_in_output("Login Administrator"))
+            print("WRONG (admin) password!! Exiting!")
+            self.tn = None
+            raise Exception("Could not login as administrator with given pw!")
+        print("OK, we have admin rights!")
+
+    def _get_name(self):
+        return RECORDER_MODEL_NAME
+
+    def _get_version(self):
+        return VERSION
+
+    def get_version(self, include_build=False, verbose_info=False):
+        if verbose_info:
+            self.tn.write("0Q")
+        else:
+            if include_build:
+                self.tn.write("*Q\n")
+            else:
+                self.tn.write("1Q\n")
+
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_bootstrap_version(self):
+        self.tn.write("2Q")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_factory_firmware_version(self):
+        self.tn.write("3Q")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_updated_firmware_version(self):
+        self.tn.write("4Q")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_part_number(self):
+        self.tn.write("N")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_model_name(self):
+        self.tn.write("1I")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_model_description(self):
+        self.tn.write("2I")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_system_memory_usage(self):
+        self.tn.write("3I")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_number_of_connected_users(self):
+        self.tn.write("10I")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_system_processer_usage(self):
+        self.tn.write("11I")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_system_processor_idle(self):
+        self.tn.write("12I")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_eth0_link_status(self):
+        self.tn.write("13I")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_file_transfer_config(self):
+        self.tn.write("38I")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_active_alarms(self):
+        self.tn.write("39I")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_unit_name(self, name: str):
+        # TODO: check name (must comply with internet host name standards)
+        self.tn.write(self.esc_char + name + "CN\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def reset_unit_name(self):
+        self.tn.write(self.esc_char + " CN\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_unit_name(self):
+        self.tn.write(self.esc_char + "CN\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_telnet_connections(self):
+        self.tn.write(self.esc_char + "CC\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_verbose_mode(self, mode: int):
+        """
+        Mode:
+        0=clear/none (default for telnet connections
+        1=verbose mode (default for USB and RS-232 host control)
+        2=tagged responses for queries
+        3=verbose mode and tagged responses for queries
+        :param mode:
+        :return:
+        """
+        if mode not in range(4):
+            raise Exception("Only values from 0 to 3 are allowed!")
+        self.tn.write(self.esc_char + str(mode) + "CV\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_verbose_mode(self):
+        self.tn.write(self.esc_char + "CV\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    """
+    def save_configuration(self):
+        pass
+
+    def restore_configuration(self):
+        pass
+    """
+
+    def reboot(self):
+        self.tn.write(self.esc_char + "1BOOT\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def restart_network(self):
+        self.tn.write(self.esc_char + "2BOOT\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def reset_flash(self):
+        """
+        Reset flash memory (excludes recording files).
+        :return:
+        """
+        self.tn.write(self.esc_char + "ZFFF\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def system_reset(self):
+        """
+        Resets device to default and deletes recorded files
+        :return:
+        """
+        self.tn.write(self.esc_char + "ZXXX\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def reset_settings_and_delete_all_files(self):
+        """
+        Reset to default except IP address, delete all user and recorded files
+        :return:
+        """
+        self.tn.write(self.esc_char + "ZY\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def absolute_reset(self):
+        """
+        Same as System Reset, plus returns the IP address and subnet mask to defaults.
+        :return:
+        """
+        self.tn.write(self.esc_char + "ZQQQ\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_front_panel_lock(self, mode: int):
+        """
+        0=Off
+        1=complete lockout (no front panel control)
+        2=menu lockout
+        3=recording controls
+        :param mode: Execute mode int code
+        :return:
+        """
+        if mode not in range(4):
+            raise Exception("Only values from 0 to 3 are allowed!")
+        self.tn.write(str(mode) + "X\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_front_panel_lock(self):
+        """
+        View executive mode.
+        0=Off
+        1=complete lockout (no front panel control)
+        2=menu lockout
+        3=recording controls
+        :return:
+        """
+        self.tn.write("X\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    """
+    A lot of stuff related to network settings (ports of services, SNMP, IP, DHCP, etc.)
+    Only some stuff will be implemented here!
+    """
+
+    """
+    def get_date_time(self):
+        pass
+
+    def get_time_zone(self):
+        pass
+
+    def get_dhcp_mode(self):
+        pass
+
+    def get_network_settings(self):
+        pass
+
+    def get_ip_address(self):
+        pass
+
+    def get_mac_address(self):
+        pass
+
+    def get_subnet_mask(self):
+        pass
+
+    def get_gateway_ip(self):
+        pass
+
+    def get_dns_server_ip(self):
+        pass
+    """
+
+    """
+    RS-232 / serial port related stuff not implemented.
+    Password and security related stuff not implemented.
+    File related stuff not implemented. (-> use sftp)
+    """
+
+    def set_input(self, input_num: int, channel_num: int):
+        """
+        Switches input # (1 to 5) to output channel (1=A [input 1 and 2], 2=B [input  3, 4 and 5])
+        :param input_num:
+        :param channel_num:
+        :return:
+        """
+        if input_num not in range(1, 6):
+            raise Exception("input_num must be a value between 1 and 5!")
+        if channel_num not in range(1, 3):
+            raise Exception("input_num must be a value between 1 and 2!")
+        self.tn.write("{}*{}!\n".format(input_num, channel_num))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_input(self, channel_num: int):
+        if channel_num not in range(1, 2):
+            raise Exception("input_num must be a value between 1 and 2!")
+        self.tn.write("{}!\n".format(channel_num))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_input_format(self, input_num: int, input_format: int):
+        """
+        Sets the input to the format, where the input_format parameter may be:
+        1 = YUVp / HDTV (default)
+        2 = YUVi
+        3 = Composite
+        :param input_num:
+        :param input_format:
+        :return:
+        """
+        if input_num not in range(1, 6):
+            raise Exception("input_num must be a value between 1 and 5!")
+        if input_format not in range(1, 4):
+            raise Exception("input_num must be a value between 1 and 3!")
+        self.tn.write("{}*{}\\\n".format(input_num, input_format))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_input_format(self, input_num: int):
+        if input_num not in range(1, 6):
+            raise Exception("input_num must be a value between 1 and 5!")
+        self.tn.write("{}\\\n".format(input_num))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_input_name(self, input_num: int, input_name: str):
+        if input_num not in range(1, 6):
+            raise Exception("input_num must be a value between 1 and 5!")
+        if len(input_name) > 16:
+            raise Exception("input_name must be no longer than 16 chars")
+        try:
+            input_name.encode('ascii')
+        except UnicodeEncodeError:
+            raise Exception("input_name must only contain ascii characters")
+        self.tn.write("{}{},{}NI\n".format(self.esc_char, input_num, input_name))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_input_name(self, input_num: int):
+        if input_num not in range(1, 6):
+            raise Exception("input_num must be a value between 1 and 5!")
+        self.tn.write("{}{}NI\n".format(self.esc_char, input_num))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_input_selction_per_channel(self):
+        self.tn.write("32I\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    """
+        Input configuration part skipped
+    """
+
+    def stop_recording(self):
+        self.tn.write("{}Y0RCDR\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def start_recording(self):
+        self.tn.write("{}Y1RCDR\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def pause_recording(self):
+        self.tn.write("{}Y2RCDR\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_recording_status(self):
+        """
+        Status may be one of:
+        0=stop
+        1=record
+        2=pause
+        :return: status
+        """
+        self.tn.write("{}YRCDR\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def extent_recording_time(self, extension_time: int):
+        """
+        Extends a scheduled recording by extension_time minutes
+        :param extension_time: must be an int from 0 to 99
+        :return:
+        """
+        if extension_time not in range(0, 100):
+            raise Exception("extension_time must be a value between 0 and 99!")
+        self.tn.write("{}E{}RCDR\n".format(self.esc_char, extension_time))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def add_chapter_marker(self):
+        self.tn.write("{}BRCDR\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def swap_channel_positions(self):
+        self.tn.write("%\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_recording_status_text(self):
+        self.tn.write("I\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_elapsed_recording_time(self):
+        self.tn.write("35I\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_remaining_recording_time(self):
+        self.tn.write("36I\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_recording_destination(self):
+        self.tn.write("37I\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    """
+        Metadata part skipped
+    """
+
+    def recall_user_preset(self, channel_number: int, preset_number: int):
+        if channel_number not in range(1, 3):
+            raise Exception("channel_number must be a value between 1 and 2!")
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("1*{}*{}.\n".format(channel_number, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def save_user_preset(self, channel_number: int, preset_number: int):
+        if channel_number not in range(1, 3):
+            raise Exception("channel_number must be a value between 1 and 2!")
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("1*{}*{},\n".format(channel_number, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_user_preset_name(self, preset_number: int, preset_name: str):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        if len(preset_name) > 16:
+            raise Exception("preset_name must be no longer than 16 chars")
+        try:
+            preset_name.encode('ascii')
+        except UnicodeEncodeError:
+            raise Exception("preset_name must only contain ascii characters")
+        self.tn.write("{}1*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_user_preset_name(self, preset_number: int):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("{}1*{}PNAM\n".format(self.esc_char, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_user_presets(self, input_number: int):
+        if input_number not in range(1, 6):
+            raise Exception("input_number must be a value between 1 and 5!")
+        self.tn.write("52*{}#\n".format(input_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    # Input Presets
+    def recall_input_preset(self, channel_number: int, preset_number: int):
+        if channel_number not in range(1, 3):
+            raise Exception("channel_number must be a value between 1 and 2!")
+        if preset_number not in range(1, 129):
+            raise Exception("preset_number must be a value between 1 and 128!")
+        self.tn.write("2*{}*{}.\n".format(channel_number, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def save_input_preset(self, channel_number: int, preset_number: int):
+        if channel_number not in range(1, 3):
+            raise Exception("channel_number must be a value between 1 and 2!")
+        if preset_number not in range(1, 129):
+            raise Exception("preset_number must be a value between 1 and 128!")
+        self.tn.write("1*{}*{},\n".format(channel_number, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_input_preset_name(self, preset_number: int, preset_name: str):
+        if preset_number not in range(1, 129):
+            raise Exception("preset_number must be a value between 1 and 128!")
+        if len(preset_name) > 16:
+            raise Exception("preset_name must be no longer than 16 chars")
+        try:
+            preset_name.encode('ascii')
+        except UnicodeEncodeError:
+            raise Exception("preset_name must only contain ascii characters")
+        self.tn.write("{}2*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_input_preset_name(self, preset_number: int):
+        if preset_number not in range(1, 129):
+            raise Exception("preset_number must be a value between 1 and 128!")
+        self.tn.write("{}2*{}PNAM\n".format(self.esc_char, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def delete_input_preset(self, preset_number: int):
+        if preset_number not in range(1, 129):
+            raise Exception("preset_number must be a value between 1 and 128!")
+        self.tn.write("{}X2*{}PRST\n".format(self.esc_char, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_input_presets(self):
+        self.tn.write("51#\n")
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    # Streaming Presets
+    def recall_streaming_preset(self, output_number: int, preset_number: int):
+        """
+        Output_number:
+        1 = Channel A
+        2 = Channel B
+        3 = Confidence Stream
+        :param preset_number:
+        :param output_number:
+        :return:
+        """
+        if output_number not in range(1, 4):
+            raise Exception("output_number must be a value between 1 and 3!")
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("3*{}*{}.\n".format(output_number, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def save_streaming_preset(self, output_number: int, preset_number: int):
+        """
+        Output_number:
+        1 = Channel A
+        2 = Channel B
+        3 = Confidence Stream
+        :param output_number:
+        :param preset_number:
+        :return:
+        """
+        if output_number not in range(1, 4):
+            raise Exception("output_number must be a value between 1 and 3!")
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("3*{}*{},\n".format(output_number, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_streaming_preset_name(self, preset_number: int, preset_name: str):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        if len(preset_name) > 16:
+            raise Exception("preset_name must be no longer than 16 chars")
+        try:
+            preset_name.encode('ascii')
+        except UnicodeEncodeError:
+            raise Exception("preset_name must only contain ascii characters")
+        self.tn.write("{}3*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_streaming_preset_name(self, preset_number: int):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("{}3*{}PNAM\n".format(self.esc_char, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def reset_streaming_preset_to_default(self, preset_number: int):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("{}X3*{}PRST\n".format(self.esc_char, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    # Encoder Presets
+    def recall_encoder_preset(self, output_number: int, preset_number: int):
+        """
+        Output_number:
+        1 = Channel A
+        2 = Channel B
+        3 = Confidence Stream
+        :param preset_number:
+        :param output_number:
+        :return:
+        """
+        if output_number not in range(1, 4):
+            raise Exception("output_number must be a value between 1 and 3!")
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("4*{}*{}.\n".format(output_number, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def save_encoder_preset(self, output_number: int, preset_number: int):
+        """
+        Output_number:
+        1 = Channel A
+        2 = Channel B
+        3 = Confidence Stream
+        :param preset_number:
+        :param output_number:
+        :return:
+        """
+        if output_number not in range(1, 4):
+            raise Exception("output_number must be a value between 1 and 3!")
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("4*{}*{},\n".format(output_number, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_encoder_preset_name(self, preset_number: int, preset_name: str):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        if len(preset_name) > 16:
+            raise Exception("preset_name must be no longer than 16 chars")
+        try:
+            preset_name.encode('ascii')
+        except UnicodeEncodeError:
+            raise Exception("preset_name must only contain ascii characters")
+        self.tn.write("{}4*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_encoder_preset_name(self, preset_number: int):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("{}4*{}PNAM\n".format(self.esc_char, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def reset_encoder_preset_to_default(self, preset_number: int):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("{}X4*{}PRST\n".format(self.esc_char, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    # Layout Presets
+    def save_layout_preset(self, preset_number: int):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("7*{},\n".format(preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def recall_layout_preset(self, preset_number: int, include_input_selections: bool = True):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        if include_input_selections:
+            self.tn.write("7*{}.\n".format(preset_number))
+        else:
+            self.tn.write("8*{}.\n".format(preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_layout_preset_name(self, preset_number: int, preset_name: str):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        if len(preset_name) > 16:
+            raise Exception("preset_name must be no longer than 16 chars")
+        try:
+            preset_name.encode('ascii')
+        except UnicodeEncodeError:
+            raise Exception("preset_name must only contain ascii characters")
+        self.tn.write("{}7*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_layout_preset_name(self, preset_number: int):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("{}7*{}PNAM\n".format(self.esc_char, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def reset_layout_preset_to_default(self, preset_number: int):
+        if preset_number not in range(1, 17):
+            raise Exception("preset_number must be a value between 1 and 16!")
+        self.tn.write("{}X7*{}PRST\n".format(self.esc_char, preset_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    """
+        Input adjustments skipped
+        Picture adjustments skipped
+    """
+
+    def mute_output(self, output_number: int):
+        """
+        Output_number:
+        1 = Channel A
+        2 = Channel B
+        :param output_number:
+        :return:
+        """
+        if output_number not in range(1, 3):
+            raise Exception("output_number must be a value between 1 and 2!")
+        self.tn.write("{}*1B\n".format(output_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def unmute_output(self, output_number: int):
+        """
+        Output_number:
+        1 = Channel A
+        2 = Channel B
+        :param output_number:
+        :return:
+        """
+        if output_number not in range(1, 3):
+            raise Exception("output_number must be a value between 1 and 2!")
+        self.tn.write("{}*0B\n".format(output_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def is_muted(self, output_number: int):
+        """
+        Output_number:
+        1 = Channel A
+        2 = Channel B
+        :param output_number:
+        :return:
+        """
+        if output_number not in range(1, 3):
+            raise Exception("output_number must be a value between 1 and 2!")
+        self.tn.write("{}B\n".format(output_number))
+        return int(TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())) > 0
+
+    """
+        EDID skipped
+        Encoder settings skipped
+        some advanced options skipped
+    """
+
+    def get_input_hdcp_status(self, input_number: int):
+        """
+        returns:
+        0 = no sink / source detected
+        1 = sink / source detected with HDCP
+        2 = sink / source detected without HDCP
+        :param input_number: from 1 to 5
+        :return:
+        """
+        if input_number not in range(1, 6):
+            raise Exception("input_number must be a value between 1 and 6!")
+        self.tn.write("{}I{}HDCP\n".format(self.esc_char, input_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_input_authorization_hdcp_on(self, input_number: int):
+        if input_number not in range(1, 6):
+            raise Exception("input_number must be a value between 1 and 6!")
+        self.tn.write("{}E{}*1HDCP\n".format(self.esc_char, input_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def set_input_authorization_hdcp_off(self, input_number: int):
+        if input_number not in range(1, 6):
+            raise Exception("input_number must be a value between 1 and 6!")
+        self.tn.write("{}E{}*0HDCP\n".format(self.esc_char, input_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_input_authorization_hdcp_status(self, input_number: int):
+        if input_number not in range(1, 6):
+            raise Exception("input_number must be a value between 1 and 6!")
+        self.tn.write("{}E{}HDCP\n".format(self.esc_char, input_number))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def enable_hdcp_notification(self):
+        self.tn.write("{}N1HDCP\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def disable_hdcp_notification(self):
+        self.tn.write("{}N0HDCP\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_hdcp_notification_status(self):
+        self.tn.write("{}NHDCP\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    # background image settings
+    def set_background_image(self, filename: str):
+        self.tn.write("{}{}RF\n".format(self.esc_char, filename))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def get_background_image_filename(self):
+        self.tn.write("{}RF\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+    def mute_background_image(self):
+        self.tn.write("{}0RF\n".format(self.esc_char))
+        return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())
+
+
+
+def main():
+    smp = SMP(HOST, PW)
+    print(smp)
+    smp._login()
+    print(smp.get_version(verbose_info=False))
+
+    print(smp.get_bootstrap_version())
+    print(smp.get_part_number())
+    print(smp.get_model_name())
+    print(smp.get_model_description())
+
+    print(smp.get_system_memory_usage())
+
+    print(smp.get_file_transfer_config())
+
+    # print(smp.get_unit_name())
+    # print(smp.set_unit_name("mzsmp"))
+    # print(smp.get_unit_name())
+    # print(smp.reset_unit_name())
+
+    print(smp.set_front_panel_lock(0))
+    print(smp.get_front_panel_lock())
+
+    print(smp.get_input_name(1))
+    print(smp.get_input_selction_per_channel())
+    print(smp.get_recording_status())
+    print("Preset Name: " + smp.get_user_preset_name(2))
+    print(smp.get_user_presets(1))
+    print(smp.get_input_presets())
+    print(smp.get_layout_preset_name(2))
+    print(smp.get_encoder_preset_name(1))
+    print(smp.get_streaming_preset_name(2))
+    print(smp.recall_encoder_preset(3, 1))
+
+    print(smp.is_muted(2))
+    print(smp.mute_output(2))
+    print(smp.is_muted(2))
+    print(smp.unmute_output(2))
+    print(smp.is_muted(2))
+
+if __name__ == '__main__':
+    main()
+