finished smp extron telnet adapter (more or less)

recorder_adapters/extron_smp.py

@@ -20,7 +20,7 @@ class SMP(TelnetAdapter):
     def login(self):
         self.tn = telnetlib.Telnet(HOST)
         self.tn.read_until("\r\nPassword:")
-        #password = getpass.getpass()
+        # password = getpass.getpass()
         password = self.admin_pw
         self.tn.write(password + "\n\r")
 
@@ -113,13 +113,11 @@ class SMP(TelnetAdapter):
         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):
-    def set_verbose_mode(self, mode:int):
         """
         Mode:
         0=clear/none (default for telnet connections
@@ -138,7 +136,6 @@ class SMP(TelnetAdapter):
         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
 
@@ -256,15 +253,15 @@ class SMP(TelnetAdapter):
         :param channel_num:
         :return:
         """
-        if input_num not in range(1,6):
+        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):
+        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):
+        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())
@@ -279,33 +276,33 @@ class SMP(TelnetAdapter):
         :param input_format:
         :return:
         """
-        if input_num not in range(1,6):
+        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):
+        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):
+        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):
+        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 not longer than 16 chars")
+            raise Exception("input_name must be no longer than 16 chars")
         try:
             input_name.encode('ascii')
-        except UnicodeDecodeError:
+        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):
+        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())
@@ -347,7 +344,7 @@ class SMP(TelnetAdapter):
         :param extension_time: must be an int from 0 to 99
         :return:
         """
-        if extension_time not in range(0,100):
+        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())
@@ -381,7 +378,354 @@ class SMP(TelnetAdapter):
     """
 
     def recall_user_preset(self, channel_number, preset_number):
-        pass  # TODO
+        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, preset_number):
+        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, preset_name):
+        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):
+        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):
+        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, preset_number):
+        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, preset_number):
+        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, preset_name):
+        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):
+        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):
+        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, preset_number):
+        """
+        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, preset_number):
+        """
+        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, preset_name):
+        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):
+        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):
+        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, preset_number):
+        """
+        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, preset_number):
+        """
+        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, preset_name):
+        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):
+        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):
+        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):
+        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, include_input_selections=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, preset_name):
+        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):
+        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):
+        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):
+        """
+        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):
+        """
+        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):
+        """
+        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):
+        """
+        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):
+        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):
+        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):
+        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())
 
 
 smp = SMP(HOST, PW)
@@ -398,7 +742,6 @@ 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())
@@ -410,3 +753,16 @@ 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))