Switching between different models + examples

app.py

@@ -1,54 +1,32 @@
 import gradio as gr
 from Bio.PDB.PDBParser import PDBParser
-from Bio.PDB.Polypeptide import is_aa, three_to_one
+# from Bio.PDB.Polypeptide import is_aa, three_to_one
 
 from wrapper import *
 
 parser = PDBParser(PERMISSIVE=1)
 
-# --- Helper functions from wrapper.py ---
-def parse_amino_acid(value):
-	value = value.upper()
-	if len(value) == 1:
-		try:
-			value = AA.one_to_three(value)
-		except Exception:
-			pass
-	if not AA.is_aa(value):
-		raise ValueError(f"'{value}' is not a valid amino acid")
-	return AA.three_to_one(value.upper())
-
-def predict_solubility(pdb_code, chain, orig, loc, mut, version=None):
-	from code.predictor import EnsemblePredictor # expensive import left for after the argument check
+def predict_solubility(pdb_code, chain, orig, loc, mut, model, version=None):
+	global MODELS
 	try:
-		
 		pdb_code, pdb_path = Type_PDB(pdb_code)
-		orig_list = parseList(orig, parse_amino_acid)
-		loc_list = parseList(loc, Type_Index)
-		mut_list = parseList(mut, parse_amino_acid)
+		loc_list = parseList(loc, Type_index)
+		orig_list = parseList(orig, Type_aminoAcid)
+		mut_list = parseList(mut, Type_aminoAcid)
 
 		if len(loc_list) != len(mut_list):
 			if len(mut_list) == 1:
 				mut_list *= len(loc_list)
 			else:
-				return "Error: Inconsistent multi-point mutant specification"
-
-		predictor = EnsemblePredictor(version=version)
-		assessment, prediction = predictor.predict_change(pdb_path, chain, orig_list, loc_list, mut_list)
-		assessment_str = {'+': 'solubilizing', 'N': 'neutral', '-': 'desolubilizing'}[assessment]
-		
-		# ternary gradient orange-black-blue
-		ORANGE = (255, 165, 0)
-		BLUESH = (100, 100, 255)
-		color = tuple((o*max(0, 1-prediction*2) + b*max(0, (2*prediction)**2-1) for o, b in zip(ORANGE, BLUESH)))
-		
-		return f"Predicted solubility change: {prediction:.3f} <span style='color: rgb{color}'>({assessment_str})</span>"
+				raise gr.Error("Inconsistent multi-point mutant specification")
+
+		return predict(pdb_path, chain, orig_list, loc_list, mut_list, weights=MODELS[model], rich_output=True)
 	except Exception as e:
 		return f"Error: {str(e)}"
 
 _pdb_code = None
 _chains = None
-def validate_PDB(pdb_code):
+def get_chains(pdb_code): # 
 	global _pdb_code, _chains
 	
 	if pdb_code != _pdb_code:
@@ -59,10 +37,14 @@ def validate_PDB(pdb_code):
 			_chains = [ch.id for ch in structure[0]]
 			return gr.update(choices=_chains, value=_chains[0])
 		except Exception as e:
-			# raise argparse.ArgumentTypeError(e)
 			raise gr.Error(str(e))
 	return gr.update(choices=_chains)
 
+from pathlib import Path
+MODELS = list((Path(__file__).parent / "models").iterdir())
+
+
+
 
 # --- Gradio Interface ---
 with gr.Blocks(
@@ -82,7 +64,6 @@ with gr.Blocks(
 			placeholder="1EER",
 			max_length=4 # 12 # new PDB identifier has a shape of: pdb_00001abc https://proteopedia.org/w/PDB_code
 		)
-		# chain = gr.Radio(label="Chain", value="A", choices=["A", "B", "C"], max_length=1, max_lines=1, scale=0)
 		chain = gr.Radio(choices=[], label="Chain", scale=1)
 
 	with gr.Row():
@@ -90,21 +71,20 @@ with gr.Blocks(
 		orig = gr.Textbox(label="Wild-type residue(s)", placeholder="F,R", scale=0)
 		mut = gr.Textbox(label="Mutant residue(s)", placeholder="D[,A]", scale=0)
 
-	# with gr.Row():
-		# verbose = gr.Checkbox(label="Verbose Output")
-		# version = gr.Textbox(label="Model Version (optional)", placeholder="v1.0")
-
+	# with gr.Accordion("Model selection"):
+	model = gr.Radio(choices=[m.stem for m in MODELS], label="Model selection", type="index", value=MODELS[0].stem)
+	
 	output = gr.HTML()
 
 	_pdb_code = None
-	pdb_code.blur(fn=validate_PDB, inputs=[pdb_code], outputs=chain)
-	pdb_code.submit(fn=validate_PDB, inputs=[pdb_code], outputs=chain)
+	pdb_code.blur(fn=get_chains, inputs=[pdb_code], outputs=chain)
+	pdb_code.submit(fn=get_chains, inputs=[pdb_code], outputs=chain)
 
 	predict_btn = gr.Button("Predict solubility effect", variant='primary', size='lg', scale=0)
 	# predict_btn.style(full_width=False)
 	dict_submit = {
 		'fn': predict_solubility,
-		'inputs': [pdb_code, chain, orig, loc, mut],
+		'inputs': [pdb_code, chain, orig, loc, mut, model],
 		'outputs': [output]
 	}
 	# submit by entering in the text boxes or by the submit button
@@ -112,7 +92,21 @@ with gr.Blocks(
 	orig.submit(**dict_submit)
 	mut.submit(**dict_submit)
 	predict_btn.click(**dict_submit)
-					  
+	
+	examples = gr.Examples(
+		examples=[
+			["1EER", "48,150", "F,R", "D"],
+			["1EER", "13", "E", "K"],
+			# ["3QIB", "A,B,P,C,D", "YP7F,TP12S;YP7F;TP12S"],
+			# ["1KNE", "A,P", ';'.join([f"TP6{a}" for a in AMINO_ACID_CODES_1])]
+		],
+		# example_labels = ["1EER F48D,R150D"],
+		inputs=[pdb_code, loc, orig, mut],
+		label="Examples (click on a line to pre-fill the inputs)",
+		cache_examples=False
+	)
+	examples.load_input_event.then(fn=get_chains, inputs=pdb_code, outputs=chain)
+	
 	gr.Markdown(value="""
 	<br/>
 	
@@ -120,6 +114,6 @@ with gr.Blocks(
 	> Velecký, J., Faldynová H., Hermosilla, P., Sandlerová, N., Dörr, M., Egersdorfová, S., Bornscheuer, U., Prokop, Z., Damborský, J., Mazurenko, S., 2025:
 	> SoluProtMut: Siamese Deep Learning for Solubility Effect Prediction in Protein Mutations and Experimental Validation.
 	> *In preparation.*
-    """)
+	""")
 
 	demo.launch()

models/DMS.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:318cb2e71583b8791f55dc7714baf08700934b8f3926d1a1b18d5b8dc10f11a1
+size 53058100

models/LGK-dupl.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a961ce6fcce281000b8b81bcbfc92b8cfacd986717f5f852f07307783f8e1f37
+size 53058100

models/TEM (bypos).pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0278374bfd523e2ee1f313a4b9a6719f2876131f1cf0e96154845c02ea57c67e
+size 53058100

wrapper.py

@@ -2,17 +2,18 @@
 #---------------------------------------------------------------------
 #---   Predictor of a protein solubility change given a mutation   ---
 #---           by Jan Velecky velda@mail.muni.cz                   ---
-#---              Loschmidt Laboratories, 2023-24                  ---
+#---              Loschmidt Laboratories, 2023-25                  ---
 #---       example use:      python3 wrapper.py -h                 ---
 #---------------------------------------------------------------------
 import argparse
 from functools import partial
 
 import Bio.PDB.Polypeptide as AA
+
 from code.data_preprocessing import get_PDB
 
 # ---------------------------------------- DATA TYPES FOR ARGPARSE ----------------------------------------
-def Type_Index(value):
+def Type_index(value): # test 1UCY 1A
 	try:
 		if not value[-1].isdigit(): # insertion code
 			ivalue = int(value[:-1])
@@ -52,7 +53,6 @@ def Type_PDB(pdb_code):
 		raise argparse.ArgumentTypeError(e)
 	return pdb_code, pdb_path
 
-
 # ----------------------------------------------END OF DATA TYPES ------------------------------------------
 
 argParser = argparse.ArgumentParser(add_help = True,
@@ -91,7 +91,7 @@ argParser.add_argument(
 argParser.add_argument(
 	'loc',
 	metavar='location',
-	type=Type_listOf(int),
+	type=Type_listOf(Type_index),
 	help="mutated position(s)   integer[n]"
 )
 argParser.add_argument(
@@ -108,6 +108,32 @@ argParser.add_argument(
 
 argParser.add_argument('--ver', default=None, help=argparse.SUPPRESS)
 
+# ---------------------------------------------- DATA PREDICTION ------------------------------------------
+
+def check_input(args):
+	pass
+
+def predict(pdb_path, chain, orig, loc, mut, weights=None, version=None, rich_output=False):
+	from code.predictor import EnsemblePredictor # expensive import left for after the argument check
+	pred_model = EnsemblePredictor(weights=weights, version=version)
+
+	assesment, prediction = pred_model.predict_change(pdb_path, chain, orig, loc, mut)
+	assesment = {'+': 'solubilizing', 'N': 'neutral', '-': 'desolubilizing'}[assesment]
+	
+	print(weights)
+	
+	if rich_output:
+		# ternary gradient orange-black-blue
+		ORANGE = (255, 165, 0)
+		BLUESH = (100, 100, 255)
+		color = tuple((o*max(0, 1-prediction*2) + b*max(0, (2*prediction)**2-1) for o, b in zip(ORANGE, BLUESH)))
+		
+		return f"Predicted solubility change: {prediction:.3f} <span style='color: rgb{color}'>({assesment})</span>"
+	else:
+		return "Predicted solubility change: %g (%s)" % (prediction, assesment)
+
+
+
 
 
 
@@ -131,11 +157,5 @@ if __name__ == '__main__':
 		# modeling.VERBOSE_LEVEL = modeling.VERBOSE_VERBOSE
 
 	# ------------------------------------- PREPROCESSING & INFERENCE --------------------------------------
-	from code.predictor import EnsemblePredictor # expensive import left for after the argument check
-
-	pred_model = EnsemblePredictor(version=args.ver)
-
-	assesment, prediction = pred_model.predict_change(pdb_path, chain, args.orig, args.loc, args.mut)
-	assesment = {'+': 'solubilizing', 'N': 'neutral', '-': 'desolubilizing'}[assesment]
 	print()
-	print("Predicted solubility change: %g (%s)" % (prediction, assesment))
+	print(predict(pdb_path, chain, args.orig, args.loc, args.mut))