class Clustalo_base_window_qt: """ Base class for ClustalOmega protocols. """ def build_algorithm_options_widgets(self): # Use full distance matrix. self.use_full_dm_rds = PyMod_radioselect_qt(label_text="Use Full Distance Matrix", buttons=('Yes', 'No')) self.use_full_dm_rds.setvalue("No") self.middle_formlayout.add_widget_to_align(self.use_full_dm_rds) # Number of (combined guide-tree/HMM) iterations. self.clustalo_iterations_enf = PyMod_entryfield_qt(label_text="Combined Iterations", value='0', validate={'validator': 'integer', 'min': 0, 'max': 5}) self.middle_formlayout.add_widget_to_align(self.clustalo_iterations_enf) self.middle_formlayout.set_input_widgets_width("auto") def get_iterations_value(self): return self.clustalo_iterations_enf.getvalue(validate=True) def get_use_full_dm_value(self): return self.use_full_dm_rds.getvalue() == "Yes"
class Phmmer_options_window_qt(BLAST_base_options_window_qt): """ Window for PHMMER searches. """ def build_algorithm_standard_options_widgets(self): self.hmmer_database_labels_dict = {} # A list containing information about the databases present in PyMod hmmer database folder. db_list = [] for db in self.protocol.databases_directories_list: db_label = "".join(db.split(".")[0:-1]) db_list.append(db_label) self.hmmer_database_labels_dict[db_label] = db # Makes the user choose the folder where the hmmer database files are stored locally. self.hmmer_database_rds = PyMod_radioselect_qt( label_text="Database Selection", buttons=db_list) self.middle_formlayout.add_widget_to_align(self.hmmer_database_rds) self.build_additional_hmmer_widgets() def build_additional_hmmer_widgets(self): pass def build_algorithm_advanced_options_widgets(self): pass def get_phmmer_database(self): return self.hmmer_database_labels_dict.get( self.hmmer_database_rds.getvalue(), None) def get_additional_hmmer_parameters(self): return {}
class Hmmscan_options_window_qt(PyMod_protocol_window_qt): def build_protocol_middle_frame(self): # Add the buttons to choose the database in which to search for domain profiles. if self.protocol.father_protocol.domain_search_mode == 'remote': self.hmmer_database_rds = PyMod_radioselect_qt( label_text="Database Selection", buttons=("PFAM", "Gene3D")) for button in self.hmmer_database_rds.get_buttons(): button.clicked.connect(self.database_opt_cmd) elif self.protocol.father_protocol.domain_search_mode == 'local': # Build the list of database names. self.protocol.hmmscan_db_dict = { } # This dictionary associates a database code (displayed in the GUI) to its filename. db_list = [] for db_filename in self.protocol.hmmscan_db_list: db_name = "".join(db_filename.split(".")[0:-2]) db_list.append(db_name) self.protocol.hmmscan_db_dict[db_name] = db_filename # Packs the PHMMER database selection widget. self.hmmer_database_rds = PyMod_radioselect_qt( label_text="Database Selection", buttons=db_list) self.middle_formlayout.add_widget_to_align(self.hmmer_database_rds) # E-value selection. self.e_value_threshold_enf = PyMod_entryfield_qt( label_text="E-value Threshold", value="1.0", validate={ 'validator': 'real', 'min': 0.0, 'max': 1000.0 }) self.middle_formlayout.add_widget_to_align(self.e_value_threshold_enf) # Note about the Gene3D and Evalues. if self.protocol.father_protocol.domain_search_mode == 'remote': info_note = ('Note: The Gene3D online database will\n' 'ignore custom cut-off parameters since\n' 'they use a post processing step that\n' 'involves preset thresholds.') self.notelabel = QtWidgets.QLabel(info_note) self.middle_formlayout.addRow(self.notelabel) self.middle_formlayout.set_input_widgets_width(140) def database_opt_cmd(self): if self.hmmer_database_rds.getvalue() == 'Gene3D': self.e_value_threshold_enf.entry.setStyleSheet( inactive_entry_style) self.e_value_threshold_enf.entry.setEnabled(False) else: self.e_value_threshold_enf.entry.setStyleSheet(active_entry_style) self.e_value_threshold_enf.entry.setEnabled(True)
class Structural_alignment_base_window_qt: def build_rmsd_option(self): # Decide whether to compute the RMSD matrix if the structural alignment. self.compute_rmsd_rds = PyMod_radioselect_qt(label_text="Compute RMSD Matrix", buttons=('Yes', 'No')) self.compute_rmsd_rds.setvalue("Yes") self.middle_formlayout.add_widget_to_align(self.compute_rmsd_rds) def get_compute_rmsd_option_value(self): return pmdt.yesno_dict[self.compute_rmsd_rds.getvalue()]
class Clustalw_base_window_qt: """ Base class for ClustalW protocols. """ def build_algorithm_options_widgets(self): # Scoring matrix radioselect. self.clustal_matrices = ["Blosum", "Pam", "Gonnet", "Id"] self.clustal_matrices_dict = { "Blosum": "blosum", "Pam": "pam", "Gonnet": "gonnet", "Id": "id" } self.matrix_rds = PyMod_radioselect_qt( label_text="Scoring Matrix Selection", buttons=self.clustal_matrices) self.matrix_rds.setvalue("Blosum") self.middle_formlayout.add_widget_to_align(self.matrix_rds) # Gap open entryfield. self.gapopen_enf = PyMod_entryfield_qt( label_text="Gap Opening Penalty", value="10.0", validate={ 'validator': 'real', 'min': 0, 'max': 1000 }) self.middle_formlayout.add_widget_to_align(self.gapopen_enf) # Gap extension entryfield. self.gapextension_enf = PyMod_entryfield_qt( label_text="Gap Extension Penalty", value="0.2", validate={ 'validator': 'real', 'min': 0, 'max': 1000 }) self.middle_formlayout.add_widget_to_align(self.gapextension_enf) self.middle_formlayout.set_input_widgets_width("auto") def get_matrix_value(self): return self.clustal_matrices_dict[self.matrix_rds.getvalue()] def get_gapopen_value(self): return self.gapopen_enf.getvalue(validate=True) def get_gapextension_value(self): return self.gapextension_enf.getvalue(validate=True)
class CAMPO_options_window_qt(PyMod_protocol_window_qt): """ Window for CAMPO options. """ def add_middle_frame_widgets(self): # Scoring matrix combobox. self.matrix_cbx = PyMod_combobox_qt(label_text="Scoring Matrix Selection", items=self.protocol.campo_matrices) self.matrix_cbx.combobox.setCurrentIndex(2) self.middle_formlayout.add_widget_to_align(self.matrix_cbx) # Gap open entryfield. self.campo_gap_penalty_enf = PyMod_entryfield_qt(label_text="Gap Score", value="-1", validate={'validator': 'integer', 'min': -1000, 'max': 0}) self.middle_formlayout.add_widget_to_align(self.campo_gap_penalty_enf) # Gap extension entryfield. self.campo_gap_to_gap_score_enf = PyMod_entryfield_qt(label_text="Gap to Gap Score", value="0", validate={'validator': 'integer', 'min': -1000, 'max': 0}) self.middle_formlayout.add_widget_to_align(self.campo_gap_to_gap_score_enf) # Toss gaps. self.campo_exclude_gaps_rds = PyMod_radioselect_qt(label_text="Toss gaps", buttons=('Yes', 'No')) self.campo_exclude_gaps_rds.setvalue("Yes") self.middle_formlayout.add_widget_to_align(self.campo_exclude_gaps_rds) self.middle_formlayout.set_input_widgets_width("auto", padding=10) def validate_input(self): params_from_gui = {} try: params_from_gui["mutational_matrix"] = self.protocol.campo_matrices_dict[self.matrix_cbx.get()] params_from_gui["gap_score"] = self.campo_gap_penalty_enf.getvalue(validate=True) params_from_gui["gap_gap_score"] = self.campo_gap_to_gap_score_enf.getvalue(validate=True) params_from_gui["toss_gaps"] = pymod_vars.yesno_dict[self.campo_exclude_gaps_rds.getvalue()] except (ValueError, KeyError) as e: return None, str(e) return params_from_gui, None
class SALIGN_seq_base_window_qt: def build_algorithm_options_widgets(self): if self.protocol.structures_are_selected: # Use structure information to guide sequence alignment. self.salign_seq_struct_rds = PyMod_radioselect_qt( label_text="Use structural information", buttons=('Yes', 'No')) self.salign_seq_struct_rds.setvalue("No") self.middle_formlayout.add_widget_to_align( self.salign_seq_struct_rds) self.middle_formlayout.set_input_widgets_width("auto") def get_use_str_information_var(self): if self.protocol.structures_are_selected: return pmdt.yesno_dict[self.salign_seq_struct_rds.getvalue()] else: return False
class MUSCLE_regular_window_qt(Regular_alignment_window_qt): def build_algorithm_options_widgets(self): # MUSCLE mode radioselect (for more information see: https://www.drive5.com/muscle/manual/). self.muscle_modes = ["Highest Accuracy", "Large Datasets", "Fastest"] self.muscle_modes_short = [ "highest_accuracy", "large_datasets", "fastest" ] self.muscle_modes_dict = dict( (k, v) for (k, v) in zip(self.muscle_modes, self.muscle_modes_short)) self.muscle_mode_rds = PyMod_radioselect_qt(label_text="MUSCLE Mode", buttons=self.muscle_modes) self.muscle_mode_rds.setvalue(self.muscle_modes[0]) self.middle_formlayout.add_widget_to_align(self.muscle_mode_rds) self.middle_formlayout.set_input_widgets_width("auto") def get_muscle_mode(self): return self.muscle_modes_dict[self.muscle_mode_rds.getvalue()]
class Contact_map_options_window_qt(PyMod_protocol_window_qt): """ Window with options for the contact map analysis. """ feature_types_list = [ "Contacts", "Distances", "Distance Difference", "Distance Mean", "Distance Std" ] interaction_centers_list = ["Carbon alpha", "Carbon beta"] default_contact_threshold = 8.0 default_distance_threshold = 18.0 default_distance_diff_threshold = 3.5 default_distance_mean_threshold = default_distance_threshold default_distance_std_threshold = default_distance_diff_threshold def build_protocol_middle_frame(self): # Feature type selection. if len(self.protocol.target_sequences) == 1: # Contact and distance. sel_option_idx = 0 all_options_idx = (0, 1) elif len(self.protocol.target_sequences ) == 2: # Distance difference, mean and std. sel_option_idx = 2 all_options_idx = (2, 3, 4) elif len(self.protocol.target_sequences) > 2: # Distance mean and std. sel_option_idx = 3 all_options_idx = (3, 4) features_buttons = [ self.feature_types_list[i] for i in all_options_idx ] self.feature_type_rds = PyMod_radioselect_qt(label_text="Feature Type", buttons=features_buttons) for button, option_idx in zip(self.feature_type_rds.get_buttons(), all_options_idx): button.clicked.connect( lambda e=None, o=option_idx: self.feature_type_state(o)) self.feature_type_rds.setvalue(self.feature_types_list[sel_option_idx]) self.middle_formlayout.add_widget_to_align(self.feature_type_rds) # Distance threshold for contacts. if len(self.protocol.target_sequences) == 1: threshold = self.default_contact_threshold elif len(self.protocol.target_sequences) == 2: threshold = self.default_distance_diff_threshold else: threshold = self.default_distance_threshold self.dist_threshold_enf = PyMod_entryfield_qt( label_text="Contact Threshold (%s)" % ("\u212B"), value=str(threshold), validate={ 'validator': 'real', 'min': 1.0, 'max': 100.0 }) self.middle_formlayout.add_widget_to_align(self.dist_threshold_enf) # Interaction center selection. self.interaction_center_rds = PyMod_radioselect_qt( label_text="Interaction Center", buttons=self.interaction_centers_list) self.interaction_center_rds.setvalue(self.interaction_centers_list[0]) self.middle_formlayout.add_widget_to_align(self.interaction_center_rds) # Reference structure combobox. if len(self.protocol.target_sequences) > 1: structures_list = [ element.my_header for element in self.protocol.target_sequences ] self.reference_combobox = PyMod_combobox_qt( label_text="Reference Structure", items=structures_list) self.reference_combobox.combobox.setCurrentIndex(0) self.middle_formlayout.add_widget_to_align(self.reference_combobox) self.middle_formlayout.set_input_widgets_width("auto", padding=10) def feature_type_state(self, state): """ Launched when the user changes the "Feature Type" in the Options window. """ # Change the status of the Tkinter checkbutton. if state == 0: self.feature_type_rds.setvalue(self.feature_types_list[0]) self.dist_threshold_enf.setvalue( str(self.default_contact_threshold)) elif state == 1: self.feature_type_rds.setvalue(self.feature_types_list[1]) self.dist_threshold_enf.setvalue( str(self.default_distance_threshold)) elif state == 2: self.feature_type_rds.setvalue(self.feature_types_list[2]) self.dist_threshold_enf.setvalue( str(self.default_distance_diff_threshold)) elif state == 3: self.feature_type_rds.setvalue(self.feature_types_list[3]) self.dist_threshold_enf.setvalue( str(self.default_distance_mean_threshold)) elif state == 4: self.feature_type_rds.setvalue(self.feature_types_list[4]) self.dist_threshold_enf.setvalue( str(self.default_distance_std_threshold)) else: KeyError(state) def get_feature_type(self): feature_type = self.feature_type_rds.getvalue() if feature_type == self.feature_types_list[0]: return "contact", feature_type elif feature_type == self.feature_types_list[1]: return "distance", feature_type elif feature_type == self.feature_types_list[2]: return "distances_difference", feature_type elif feature_type == self.feature_types_list[3]: return "distances_mean", feature_type elif feature_type == self.feature_types_list[4]: return "distances_std", feature_type else: raise KeyError(feature_type) def get_interaction_center(self): int_center_string = self.interaction_center_rds.getvalue() if int_center_string == self.interaction_centers_list[0]: return "ca" elif int_center_string == self.interaction_centers_list[1]: return "cb" else: raise KeyError(int_center_string) def get_reference_id(self): try: return self.reference_combobox.get_index() except: print("- WARNING: could not obtain the reference structure id.") return 0
class Ramachandran_plot_options_window_qt(PyMod_protocol_window_qt): def build_protocol_middle_frame(self): """ Allow to choose between plotting all amino acids types or only a subset of them. """ # Radioselect. aa_select_choices = ("Use all amino acids", "Select amino acids types") aa_select_choices_values = ["all", "single"] self.aa_select_choices_dict = dict([ (k, v) for (k, v) in zip(aa_select_choices, aa_select_choices_values) ]) self.aa_select_rds = PyMod_radioselect_qt( label_text="Select Amino Acids", buttons=aa_select_choices) self.aa_select_rds.setvalue(aa_select_choices[0]) self.aa_select_rds.buttons_dict[aa_select_choices[0]].clicked.connect( self.hide_select_single_aa_frame) self.aa_select_rds.buttons_dict[aa_select_choices[1]].clicked.connect( self.show_select_single_aa_frame) self.middle_formlayout.add_widget_to_align(self.aa_select_rds) # Checkboxes for selecting single amino acids. self.aa_select_grid_layout = QtWidgets.QGridLayout() self.aa_select_rds.input.addLayout(self.aa_select_grid_layout) self.aa_checkbutton = {} self.aa_freq_dict = {} self.aa_checkbutton_list = [] for i, aa in enumerate(prot_standard_one_letter): # Get the number of aa in the sequence. aa_freq = str(self.protocol.target_sequence.my_sequence).count(aa) self.aa_freq_dict[aa] = aa_freq # Build a checkbox for the aa. checkbox = QtWidgets.QCheckBox( pmsm.one2three(aa) + " (" + str(aa_freq) + ")") checkbox.setEnabled(False) self.aa_select_grid_layout.addWidget(checkbox, int(i % 10), int(i / 10)) self.aa_checkbutton[aa] = checkbox self.aa_checkbutton_list.append(checkbox) self.aa_select_grid_layout.setAlignment(QtCore.Qt.AlignLeft) self.middle_formlayout.set_input_widgets_width("auto", padding=40) def show_select_single_aa_frame(self): for aa in prot_standard_one_letter: # Only enable selection of aa present in primary sequence. if self.aa_freq_dict[aa] != 0: self.aa_checkbutton[aa].setEnabled(True) def hide_select_single_aa_frame(self): for checkbox in self.aa_checkbutton_list: checkbox.setEnabled(False) def get_aa_selection_mode(self): return self.aa_select_choices_dict[self.aa_select_rds.getvalue()]
class Search_string_window_qt(PyMod_tool_window_qt): inactive_results_color = inactive_bg_color found_results_color = success_bg_color not_found_results_color = failure_bg_color default_message = "Type a pattern and press Enter..." def __init__(self, parent, pymod_elements, *args, **configs): self.pymod_element = pymod_elements[0] PyMod_tool_window_qt.__init__(self, parent, *args, **configs) def add_middle_frame_widgets(self): #------------------------------------- # Form layout for input and results. - #------------------------------------- entries_width = 340 # Entryfield for inserting a subsequence. self.search_string_enf = PyMod_entryfield_qt( label_text="Search For", value="", enter_command=self.submit_command) self.search_string_enf.set_input_widget_width(entries_width) self.middle_formlayout.add_widget_to_align(self.search_string_enf, align=False) # Entryfield for showing the results. self.results_enf = PyMod_entryfield_qt(label_text="", value=self.default_message, readonly=True) self.set_results_entry_bg(self.inactive_results_color) self.results_enf.set_input_widget_width(entries_width) self.middle_formlayout.add_widget_to_align(self.results_enf, align=False) #--------------------------- # Form layout for options. - #--------------------------- # Use regular expressions. self.use_regex_rds = PyMod_radioselect_qt(label_text="Use Regex", buttons=("Yes", "No")) self.use_regex_rds.setvalue("No") self.middle_formlayout.add_widget_to_align(self.use_regex_rds) # Highlight color selection. color_buttons = ("yellow", "red", "green", "cyan") # "violet" self.highlight_color_rds = PyMod_radioselect_qt( label_text='Highlight Color', buttons=color_buttons) self.highlight_color_rds.setvalue('yellow') self.middle_formlayout.add_widget_to_align(self.highlight_color_rds) if self.pymod_element.has_structure(): self.select_in_pymol_rds = PyMod_radioselect_qt( label_text='Select in PyMOL', buttons=("Yes", "No")) self.select_in_pymol_rds.setvalue('No') self.middle_formlayout.add_widget_to_align( self.select_in_pymol_rds) self.middle_formlayout.set_input_widgets_width(width="auto") def get_search_string(self): return self.search_string_enf.getvalue() def get_regex_use(self): use_regex_val = self.use_regex_rds.getvalue() if use_regex_val == "Yes": return True elif use_regex_val == "No": return False else: raise KeyError(use_regex_val) def get_highlight_color(self): return self.highlight_color_rds.getvalue() def show_results(self, message, state): self.results_enf.setvalue(message) if state == "found": self.set_results_entry_bg(self.found_results_color) elif state == "not_found": self.set_results_entry_bg(self.not_found_results_color) elif state == "empty": self.set_results_entry_bg(self.inactive_results_color) else: raise KeyError(state) def set_results_entry_bg(self, color): self.results_enf.input.setStyleSheet( "background-color: %s; color: black" % color) def get_select_in_pymol(self): return _get_select_in_pymol(self)