Upload 5 files

ProteinMPNN-main/helper_scripts/assign_fixed_chains.py

@@ -0,0 +1,40 @@
+import argparse
+
+def a_f_c(input_path, output_path, chain_list):
+    import json
+
+    with open(input_path.name, 'r') as json_file:
+        json_list = list(json_file)
+    
+    global_designed_chain_list = []
+    if chain_list != '':
+        global_designed_chain_list = [str(item) for item in chain_list.split()]
+    my_dict = {}
+    for json_str in json_list:
+        result = json.loads(json_str)
+        all_chain_list = [item[-1:] for item in list(result) if item[:9]=='seq_chain'] #['A','B', 'C',...]
+        if len(global_designed_chain_list) > 0:
+            designed_chain_list = global_designed_chain_list
+        else:
+            #manually specify, e.g.
+            designed_chain_list = ["A"]
+        fixed_chain_list = [letter for letter in all_chain_list if letter not in designed_chain_list] #fix/do not redesign these chains 
+        my_dict[result['name']]= (designed_chain_list, fixed_chain_list)
+    
+    with open(output_path, 'w') as f:
+        f.write(json.dumps(my_dict) + '\n')
+    return output_path
+
+
+# if __name__ == "__main__":
+#     argparser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+#     argparser.add_argument("--input_path", type=str, help="Path to the parsed PDBs")
+#     argparser.add_argument("--output_path", type=str, help="Path to the output dictionary")
+#     argparser.add_argument("--chain_list", type=str, default='', help="List of the chains that need to be designed")
+#
+#     args = argparser.parse_args()
+#     main(args)
+
+# Output looks like this:
+# {"5TTA": [["A"], ["B"]], "3LIS": [["A"], ["B"]]}
+

ProteinMPNN-main/helper_scripts/make_bias_AA.py

@@ -0,0 +1,28 @@
+import argparse 
+
+def m_b_A(output_path, AA_list, bias_list):
+
+    import numpy as np
+    import json
+
+    bias_list = [float(item) for item in bias_list.split()]
+    AA_list = [str(item) for item in AA_list.split()]
+
+    my_dict = dict(zip(AA_list, bias_list))
+
+    with open(output_path, 'w') as f:
+        f.write(json.dumps(my_dict) + '\n')
+    return output_path
+
+
+# if __name__ == "__main__":
+#     argparser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+#     argparser.add_argument("--output_path", type=str, help="Path to the output dictionary")
+#     argparser.add_argument("--AA_list", type=str, default='', help="List of AAs to be biased")
+#     argparser.add_argument("--bias_list", type=str, default='', help="AA bias strengths")
+#
+#     args = argparser.parse_args()
+#     main(args)
+
+#e.g. output
+#{"A": -0.01, "G": 0.02}

ProteinMPNN-main/helper_scripts/make_fixed_positions_dict.py

@@ -0,0 +1,60 @@
+import argparse
+
+def m_f_p_d(input_path, output_path, chain_list, position_list, specify_non_fixed):
+    import glob
+    import random
+    import numpy as np
+    import json
+    import itertools
+    
+    with open(input_path.name, 'r') as json_file:
+        json_list = list(json_file)
+    
+    fixed_list = [[int(item) for item in one.split()] for one in position_list.split(",")]
+    global_designed_chain_list = [str(item) for item in chain_list.split()]
+    my_dict = {}
+    
+    if not specify_non_fixed:
+        for json_str in json_list:
+            result = json.loads(json_str)
+            all_chain_list = [item[-1:] for item in list(result) if item[:9]=='seq_chain']
+            fixed_position_dict = {}
+            for i, chain in enumerate(global_designed_chain_list):
+                fixed_position_dict[chain] = fixed_list[i]
+            for chain in all_chain_list:
+                if chain not in global_designed_chain_list:       
+                    fixed_position_dict[chain] = []
+            my_dict[result['name']] = fixed_position_dict
+    else:
+        for json_str in json_list:
+            result = json.loads(json_str)
+            all_chain_list = [item[-1:] for item in list(result) if item[:9]=='seq_chain']
+            fixed_position_dict = {}   
+            for chain in all_chain_list:
+                seq_length = len(result[f'seq_chain_{chain}'])
+                all_residue_list = (np.arange(seq_length)+1).tolist()
+                if chain not in global_designed_chain_list:
+                    fixed_position_dict[chain] = all_residue_list
+                else:
+                    idx = np.argwhere(np.array(global_designed_chain_list) == chain)[0][0]
+                    fixed_position_dict[chain] = list(set(all_residue_list)-set(fixed_list[idx]))
+            my_dict[result['name']] = fixed_position_dict
+
+    with open(output_path, 'w') as f:
+        f.write(json.dumps(my_dict) + '\n')
+    return output_path
+    
+    #e.g. output
+    #{"5TTA": {"A": [1, 2, 3, 7, 8, 9, 22, 25, 33], "B": []}, "3LIS": {"A": [], "B": []}}
+
+# if __name__ == "__main__":
+#     argparser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+#     argparser.add_argument("--input_path", type=str, help="Path to the parsed PDBs")
+#     argparser.add_argument("--output_path", type=str, help="Path to the output dictionary")
+#     argparser.add_argument("--chain_list", type=str, default='', help="List of the chains that need to be fixed")
+#     argparser.add_argument("--position_list", type=str, default='', help="Position lists, e.g. 11 12 14 18, 1 2 3 4 for first chain and the second chain")
+#     argparser.add_argument("--specify_non_fixed", action="store_true", default=False, help="Allows specifying just residues that need to be designed (default: false)")
+#
+#     args = argparser.parse_args()
+#     main(args)
+

ProteinMPNN-main/helper_scripts/make_tied_positions_dict.py

@@ -0,0 +1,61 @@
+import argparse
+
+def m_t_p_d(input_path, output_path, chain_list, position_list, homooligomer):
+
+    import glob
+    import random
+    import numpy as np
+    import json
+    import itertools
+    
+    with open(input_path.name, 'r') as json_file:
+        json_list = list(json_file)
+    
+    homooligomeric_state = int(homooligomer)
+
+    if homooligomeric_state == 0:
+        tied_list = [[int(item) for item in one.split()] for one in position_list.split(",")]
+        global_designed_chain_list = [str(item) for item in chain_list.split()]
+        my_dict = {}
+        for json_str in json_list:
+            result = json.loads(json_str)
+            all_chain_list = sorted([item[-1:] for item in list(result) if item[:9]=='seq_chain']) #A, B, C, ...
+            tied_positions_list = []
+            for i, pos in enumerate(tied_list[0]):
+                temp_dict = {}
+                for j, chain in enumerate(global_designed_chain_list):
+                    temp_dict[chain] = [tied_list[j][i]] #needs to be a list
+                tied_positions_list.append(temp_dict)
+            my_dict[result['name']] = tied_positions_list
+    else:
+        my_dict = {}
+        for json_str in json_list:
+            result = json.loads(json_str)
+            all_chain_list = sorted([item[-1:] for item in list(result) if item[:9]=='seq_chain']) #A, B, C, ...
+            tied_positions_list = []
+            chain_length = len(result[f"seq_chain_{all_chain_list[0]}"])
+            for i in range(1,chain_length+1):
+                temp_dict = {}
+                for j, chain in enumerate(all_chain_list):
+                    temp_dict[chain] = [i] #needs to be a list
+                tied_positions_list.append(temp_dict)
+            my_dict[result['name']] = tied_positions_list
+ 
+    with open(output_path, 'w') as f:
+        f.write(json.dumps(my_dict) + '\n')
+    return output_path
+# if __name__ == "__main__":
+#     argparser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+#     argparser.add_argument("--input_path", type=str, help="Path to the parsed PDBs")
+#     argparser.add_argument("--output_path", type=str, help="Path to the output dictionary")
+#     argparser.add_argument("--chain_list", type=str, default='', help="List of the chains that need to be fixed")
+#     argparser.add_argument("--position_list", type=str, default='', help="Position lists, e.g. 11 12 14 18, 1 2 3 4 for first chain and the second chain")
+#     argparser.add_argument("--homooligomer", type=int, default=0, help="If 0 do not use, if 1 then design homooligomer")
+#
+#     args = argparser.parse_args()
+#     main(args)
+
+
+#e.g. output
+#{"5TTA": [], "3LIS": [{"A": [1], "B": [1]}, {"A": [2], "B": [2]}, {"A": [3], "B": [3]}, {"A": [4], "B": [4]}, {"A": [5], "B": [5]}, {"A": [6], "B": [6]}, {"A": [7], "B": [7]}, {"A": [8], "B": [8]}, {"A": [9], "B": [9]}, {"A": [10], "B": [10]}, {"A": [11], "B": [11]}, {"A": [12], "B": [12]}, {"A": [13], "B": [13]}, {"A": [14], "B": [14]}, {"A": [15], "B": [15]}, {"A": [16], "B": [16]}, {"A": [17], "B": [17]}, {"A": [18], "B": [18]}, {"A": [19], "B": [19]}, {"A": [20], "B": [20]}, {"A": [21], "B": [21]}, {"A": [22], "B": [22]}, {"A": [23], "B": [23]}, {"A": [24], "B": [24]}, {"A": [25], "B": [25]}, {"A": [26], "B": [26]}, {"A": [27], "B": [27]}, {"A": [28], "B": [28]}, {"A": [29], "B": [29]}, {"A": [30], "B": [30]}, {"A": [31], "B": [31]}, {"A": [32], "B": [32]}, {"A": [33], "B": [33]}, {"A": [34], "B": [34]}, {"A": [35], "B": [35]}, {"A": [36], "B": [36]}, {"A": [37], "B": [37]}, {"A": [38], "B": [38]}, {"A": [39], "B": [39]}, {"A": [40], "B": [40]}, {"A": [41], "B": [41]}, {"A": [42], "B": [42]}, {"A": [43], "B": [43]}, {"A": [44], "B": [44]}, {"A": [45], "B": [45]}, {"A": [46], "B": [46]}, {"A": [47], "B": [47]}, {"A": [48], "B": [48]}, {"A": [49], "B": [49]}, {"A": [50], "B": [50]}, {"A": [51], "B": [51]}, {"A": [52], "B": [52]}, {"A": [53], "B": [53]}, {"A": [54], "B": [54]}, {"A": [55], "B": [55]}, {"A": [56], "B": [56]}, {"A": [57], "B": [57]}, {"A": [58], "B": [58]}, {"A": [59], "B": [59]}, {"A": [60], "B": [60]}, {"A": [61], "B": [61]}, {"A": [62], "B": [62]}, {"A": [63], "B": [63]}, {"A": [64], "B": [64]}, {"A": [65], "B": [65]}, {"A": [66], "B": [66]}, {"A": [67], "B": [67]}, {"A": [68], "B": [68]}, {"A": [69], "B": [69]}, {"A": [70], "B": [70]}, {"A": [71], "B": [71]}, {"A": [72], "B": [72]}, {"A": [73], "B": [73]}, {"A": [74], "B": [74]}, {"A": [75], "B": [75]}, {"A": [76], "B": [76]}, {"A": [77], "B": [77]}, {"A": [78], "B": [78]}, {"A": [79], "B": [79]}, {"A": [80], "B": [80]}, {"A": [81], "B": [81]}, {"A": [82], "B": [82]}, {"A": [83], "B": [83]}, {"A": [84], "B": [84]}, {"A": [85], "B": [85]}, {"A": [86], "B": [86]}, {"A": [87], "B": [87]}, {"A": [88], "B": [88]}, {"A": [89], "B": [89]}, {"A": [90], "B": [90]}, {"A": [91], "B": [91]}, {"A": [92], "B": [92]}, {"A": [93], "B": [93]}, {"A": [94], "B": [94]}, {"A": [95], "B": [95]}, {"A": [96], "B": [96]}]}
+

ProteinMPNN-main/helper_scripts/parse_multiple_chains.py

@@ -0,0 +1,167 @@
+import argparse
+
+
+def p_m_c(input_path, output_path, ca_only):
+    import numpy as np
+    import os, time, gzip, json
+    import glob
+
+    # folder_with_pdbs_path = input_path
+    save_path = output_path
+    # ca_only = args.ca_only
+    # ca_only = False
+
+    alpha_1 = list("ARNDCQEGHILKMFPSTWYV-")
+    states = len(alpha_1)
+    alpha_3 = ['ALA', 'ARG', 'ASN', 'ASP', 'CYS', 'GLN', 'GLU', 'GLY', 'HIS', 'ILE',
+               'LEU', 'LYS', 'MET', 'PHE', 'PRO', 'SER', 'THR', 'TRP', 'TYR', 'VAL', 'GAP']
+
+    aa_1_N = {a: n for n, a in enumerate(alpha_1)}
+    aa_3_N = {a: n for n, a in enumerate(alpha_3)}
+    aa_N_1 = {n: a for n, a in enumerate(alpha_1)}
+    aa_1_3 = {a: b for a, b in zip(alpha_1, alpha_3)}
+    aa_3_1 = {b: a for a, b in zip(alpha_1, alpha_3)}
+
+    def AA_to_N(x):
+        # ["ARND"] -> [[0,1,2,3]]
+        x = np.array(x);
+        if x.ndim == 0: x = x[None]
+        return [[aa_1_N.get(a, states - 1) for a in y] for y in x]
+
+    def N_to_AA(x):
+        # [[0,1,2,3]] -> ["ARND"]
+        x = np.array(x);
+        if x.ndim == 1: x = x[None]
+        return ["".join([aa_N_1.get(a, "-") for a in y]) for y in x]
+
+    def parse_PDB_biounits(x, atoms=['N', 'CA', 'C'], chain=None):
+        '''
+      input:  x = PDB filename
+              atoms = atoms to extract (optional)
+      output: (length, atoms, coords=(x,y,z)), sequence
+      '''
+        xyz, seq, min_resn, max_resn = {}, {}, 1e6, -1e6
+        for line in open(x, "rb"):
+            line = line.decode("utf-8", "ignore").rstrip()
+
+            if line[:6] == "HETATM" and line[17:17 + 3] == "MSE":
+                line = line.replace("HETATM", "ATOM  ")
+                line = line.replace("MSE", "MET")
+
+            if line[:4] == "ATOM":
+                ch = line[21:22]
+                if ch == chain or chain is None:
+                    atom = line[12:12 + 4].strip()
+                    resi = line[17:17 + 3]
+                    resn = line[22:22 + 5].strip()
+                    x, y, z = [float(line[i:(i + 8)]) for i in [30, 38, 46]]
+
+                    if resn[-1].isalpha():
+                        resa, resn = resn[-1], int(resn[:-1]) - 1
+                    else:
+                        resa, resn = "", int(resn) - 1
+                    #         resn = int(resn)
+                    if resn < min_resn:
+                        min_resn = resn
+                    if resn > max_resn:
+                        max_resn = resn
+                    if resn not in xyz:
+                        xyz[resn] = {}
+                    if resa not in xyz[resn]:
+                        xyz[resn][resa] = {}
+                    if resn not in seq:
+                        seq[resn] = {}
+                    if resa not in seq[resn]:
+                        seq[resn][resa] = resi
+
+                    if atom not in xyz[resn][resa]:
+                        xyz[resn][resa][atom] = np.array([x, y, z])
+
+        # convert to numpy arrays, fill in missing values
+        seq_, xyz_ = [], []
+        try:
+            for resn in range(min_resn, max_resn + 1):
+                if resn in seq:
+                    for k in sorted(seq[resn]): seq_.append(aa_3_N.get(seq[resn][k], 20))
+                else:
+                    seq_.append(20)
+                if resn in xyz:
+                    for k in sorted(xyz[resn]):
+                        for atom in atoms:
+                            if atom in xyz[resn][k]:
+                                xyz_.append(xyz[resn][k][atom])
+                            else:
+                                xyz_.append(np.full(3, np.nan))
+                else:
+                    for atom in atoms: xyz_.append(np.full(3, np.nan))
+            return np.array(xyz_).reshape(-1, len(atoms), 3), N_to_AA(np.array(seq_))
+        except TypeError:
+            return 'no_chain', 'no_chain'
+
+    pdb_dict_list = []
+    c = 0
+
+    # if folder_with_pdbs_path[-1] != '/':
+    #     folder_with_pdbs_path = folder_with_pdbs_path + '/'
+
+    init_alphabet = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
+                     'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+                     'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
+    extra_alphabet = [str(item) for item in list(np.arange(300))]
+    chain_alphabet = init_alphabet + extra_alphabet
+
+    # biounit_names = glob.glob(folder_with_pdbs_path + '*.pdb')
+    for input in input_path:
+        my_dict = {}
+        s = 0
+        concat_seq = ''
+        concat_N = []
+        concat_CA = []
+        concat_C = []
+        concat_O = []
+        concat_mask = []
+        coords_dict = {}
+        for letter in chain_alphabet:
+            if ca_only:
+                sidechain_atoms = ['CA']
+            else:
+                sidechain_atoms = ['N', 'CA', 'C', 'O']
+            xyz, seq = parse_PDB_biounits(input.name, atoms=sidechain_atoms, chain=letter)
+            if type(xyz) != str:
+                concat_seq += seq[0]
+                my_dict['seq_chain_' + letter] = seq[0]
+                coords_dict_chain = {}
+                if ca_only:
+                    coords_dict_chain['CA_chain_' + letter] = xyz.tolist()
+                else:
+                    coords_dict_chain['N_chain_' + letter] = xyz[:, 0, :].tolist()
+                    coords_dict_chain['CA_chain_' + letter] = xyz[:, 1, :].tolist()
+                    coords_dict_chain['C_chain_' + letter] = xyz[:, 2, :].tolist()
+                    coords_dict_chain['O_chain_' + letter] = xyz[:, 3, :].tolist()
+                my_dict['coords_chain_' + letter] = coords_dict_chain
+                s += 1
+        na = input.name
+        fi = na.rfind("\\")
+        my_dict['name'] = na[(fi + 1):(fi+5)]
+        my_dict['num_of_chains'] = s
+        my_dict['seq'] = concat_seq
+        if s < len(chain_alphabet):
+            pdb_dict_list.append(my_dict)
+            c += 1
+
+    with open(save_path, 'w') as f:
+        for entry in pdb_dict_list:
+            f.write(json.dumps(entry) + '\n')
+    return save_path
+
+
+# if __name__ == "__main__":
+#     argparser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+#
+#     argparser.add_argument("--input_path", type=str, help="Path to a folder with pdb files, e.g. /home/my_pdbs/")
+#     argparser.add_argument("--output_path", type=str, help="Path where to save .jsonl dictionary of parsed pdbs")
+#     argparser.add_argument("--ca_only", action="store_true", default=False,
+#                            help="parse a backbone-only structure (default: false)")
+#
+#     args = argparser.parse_args()
+#     main(args)