Fast-HInt-ppi 0.1.2__tar.gz → 0.1.3__tar.gz

fast_hint_ppi-0.1.3/Fast_HInt/script_pi_score/__init__.py

@@ -0,0 +1 @@
+"""script_pi_score"""

fast_hint_ppi-0.1.3/Fast_HInt/script_pi_score/calculate_mpdockq.py

@@ -0,0 +1,190 @@
+#Adapted from calculate_mpdockq.py (https://github.com/KosinskiLab/AlphaPulldown/blob/main/alphapulldown/analysis_pipeline/alpha_analysis_jax0.4.def)
+
+import numpy as np
+from collections import defaultdict
+import math
+
+################FUNCTIONS#################
+def parse_atm_record(line):
+    '''Get the atm record
+    '''
+    record = defaultdict()
+    record['name'] = line[0:6].strip()
+    record['atm_no'] = int(line[6:11].strip())
+    record['atm_name'] = line[12:16].strip()
+    record['atm_alt'] = line[17]
+    record['res_name'] = line[17:20].strip()
+    record['chain'] = line[21]
+    record['res_no'] = int(line[22:26].strip())
+    record['insert'] = line[26].strip()
+    record['resid'] = line[22:29]
+    record['x'] = float(line[30:38])
+    record['y'] = float(line[38:46])
+    record['z'] = float(line[46:54])
+    record['occ'] = float(line[54:60])
+    record['B'] = float(line[60:66])
+
+    return record
+
+def read_pdb(pdbfile):
+    '''Read a pdb file per chain
+    '''
+    pdb_chains = {}
+    chain_coords = {}
+    chain_CA_inds = {}
+    chain_CB_inds = {}
+
+    with open(pdbfile) as file:
+        for line in file:
+            if 'ATOM' in line:
+                record = parse_atm_record(line)
+                if record['chain'] in [*pdb_chains.keys()]:
+                    pdb_chains[record['chain']].append(line)
+                    chain_coords[record['chain']].append([record['x'],record['y'],record['z']])
+                    coord_ind+=1
+                    if record['atm_name']=='CA':
+                        chain_CA_inds[record['chain']].append(coord_ind)
+                    if record['atm_name']=='CB' or (record['atm_name']=='CA' and record['res_name']=='GLY'):
+                        chain_CB_inds[record['chain']].append(coord_ind)
+
+
+                else:
+                    pdb_chains[record['chain']] = [line]
+                    chain_coords[record['chain']]= [[record['x'],record['y'],record['z']]]
+                    chain_CA_inds[record['chain']]= []
+                    chain_CB_inds[record['chain']]= []
+                    #Reset coord ind
+                    coord_ind = 0
+
+
+    return pdb_chains, chain_coords, chain_CA_inds, chain_CB_inds
+
+def read_plddt(best_plddt, chain_CA_inds):
+    '''Get the plDDT for each chain
+    '''
+    chain_names = chain_CA_inds.keys()
+    chain_lengths = dict()
+    for name in chain_names:
+        curr_len = len(chain_CA_inds[name])
+        chain_lengths[name] = curr_len
+    
+    plddt_per_chain = dict()
+    curr_len = 0
+    for k,v in chain_lengths.items():
+        curr_plddt = best_plddt[curr_len:curr_len+v]
+        plddt_per_chain[k] = curr_plddt
+        curr_len += v 
+    return plddt_per_chain
+
+def score_complex(path_coords, path_CB_inds, path_plddt):
+    '''
+    Score all interfaces in the current complex
+
+    Modified from the score_complex() function in MoLPC repo: 
+    https://gitlab.com/patrickbryant1/molpc/-/blob/main/src/complex_assembly/score_entire_complex.py#L106-154
+    '''
+
+    chains = [*path_coords.keys()]
+    chain_inds = np.arange(len(chains))
+    complex_score = 0
+    #Get interfaces per chain
+    for i in chain_inds:
+        chain_i = chains[i]
+        chain_coords = np.array(path_coords[chain_i])
+        chain_CB_inds = path_CB_inds[chain_i]
+        l1 = len(chain_CB_inds)
+        chain_CB_coords = chain_coords[chain_CB_inds]
+        chain_plddt = path_plddt[chain_i]
+ 
+        for int_i in np.setdiff1d(chain_inds, i):
+            int_chain = chains[int_i]
+            int_chain_CB_coords = np.array(path_coords[int_chain])[path_CB_inds[int_chain]]
+            int_chain_plddt = path_plddt[int_chain]
+            #Calc 2-norm
+            mat = np.append(chain_CB_coords,int_chain_CB_coords,axis=0)
+            a_min_b = mat[:,np.newaxis,:] -mat[np.newaxis,:,:]
+            dists = np.sqrt(np.sum(a_min_b.T ** 2, axis=0)).T
+            contact_dists = dists[:l1,l1:]
+            contacts = np.argwhere(contact_dists<=8)
+            #The first axis contains the contacts from chain 1
+            #The second the contacts from chain 2
+            if contacts.shape[0]>0:
+                av_if_plDDT = np.concatenate((chain_plddt[contacts[:,0]], int_chain_plddt[contacts[:,1]])).mean()
+                complex_score += np.log10(contacts.shape[0]+1)*av_if_plDDT
+
+    return complex_score, len(chains)
+
+def calculate_mpDockQ(complex_score):
+    """
+    A function that returns a complex's mpDockQ score after 
+    calculating complex_score
+    """
+    L = 0.827
+    x_0 = 261.398
+    k = 0.036
+    b = 0.221
+    return L/(1+math.exp(-1*k*(complex_score-x_0))) + b
+
+def read_pdb_pdockq(pdbfile):
+    '''Read a pdb file predicted with AF and rewritten to conatin all chains
+    Adepted from FoldDock repo:
+    https://gitlab.com/ElofssonLab/FoldDock/-/blob/main/src/pdockq.py#L34-59
+    '''
+
+    chain_coords, chain_plddt = {}, {}
+    with open(pdbfile, 'r') as file:
+        for line in file:
+            if not line.startswith('ATOM'):
+                continue
+            record = parse_atm_record(line)
+            #Get CB - CA for GLY
+            if record['atm_name']=='CB' or (record['atm_name']=='CA' and record['res_name']=='GLY'):
+                if record['chain'] in [*chain_coords.keys()]:
+                    chain_coords[record['chain']].append([record['x'],record['y'],record['z']])
+                    chain_plddt[record['chain']].append(record['B'])
+                else:
+                    chain_coords[record['chain']] = [[record['x'],record['y'],record['z']]]
+                    chain_plddt[record['chain']] = [record['B']]
+
+
+    #Convert to arrays
+    for chain in chain_coords:
+        chain_coords[chain] = np.array(chain_coords[chain])
+        chain_plddt[chain] = np.array(chain_plddt[chain])
+
+    return chain_coords, chain_plddt
+
+
+def calc_pdockq(chain_coords, chain_plddt, t):
+    '''Calculate the pDockQ scores
+    pdockQ = L / (1 + np.exp(-k*(x-x0)))+b
+    L= 0.724 x0= 152.611 k= 0.052 and b= 0.018
+
+    Modified from the calc_pdockq() from FoldDock repo: 
+    https://gitlab.com/ElofssonLab/FoldDock/-/blob/main/src/pdockq.py#L62
+    '''
+
+    #Get coords and plddt per chain
+    ch1, ch2 = [*chain_coords.keys()]
+    coords1, coords2 = chain_coords[ch1], chain_coords[ch2]
+    plddt1, plddt2 = chain_plddt[ch1], chain_plddt[ch2]
+
+    #Calc 2-norm
+    mat = np.append(coords1, coords2,axis=0)
+    a_min_b = mat[:,np.newaxis,:] -mat[np.newaxis,:,:]
+    dists = np.sqrt(np.sum(a_min_b.T ** 2, axis=0)).T
+    l1 = len(coords1)
+    contact_dists = dists[:l1,l1:] #upper triangular --> first dim = chain 1
+    contacts = np.argwhere(contact_dists<=t)
+
+    if contacts.shape[0]<1:
+        pdockq=0
+    else:
+        #Get the average interface plDDT
+        avg_if_plddt = np.average(np.concatenate([plddt1[np.unique(contacts[:,0])], plddt2[np.unique(contacts[:,1])]]))
+        #Get the number of interface contacts
+        n_if_contacts = contacts.shape[0]
+        x = avg_if_plddt*np.log10(n_if_contacts)
+        pdockq = 0.724 / (1 + np.exp(-0.052*(x-152.611)))+0.018
+
+    return pdockq

fast_hint_ppi-0.1.3/Fast_HInt/script_pi_score/clean_pdb.py

@@ -0,0 +1,62 @@
+#Adapted from clean_pdb.py (https://gitlab.com/topf-lab/pi_score/-/tree/master/score_scripts)
+
+from Bio.PDB import *
+
+dict_aa = {'CYS': 'C', 'ASP': 'D', 'SER': 'S', 'GLN': 'Q', 'LYS': 'K',
+           'ILE': 'I', 'PRO': 'P', 'THR': 'T', 'PHE': 'F', 'ASN': 'N',
+           'GLY': 'G', 'HIS': 'H', 'LEU': 'L', 'ARG': 'R', 'TRP': 'W',
+           'ALA': 'A', 'VAL':'V', 'GLU': 'E', 'TYR': 'Y', 'MET': 'M'}
+
+def str_object(pdbfile):
+    '''
+    Given a pdb file creates a structure object
+    '''
+    parser = PDBParser(QUIET=True)
+    s = parser.get_structure('id', pdbfile)
+    return s
+
+class SelectResidues(Select):
+    """ Only accept the specified residues when saving. """
+    def accept_residue(self, residue):
+        #print residue.get_resname(),residue.get_full_id()[3][0]
+        if residue.get_full_id()[3][0] != 'W' and not residue.get_full_id()[3][0].startswith('H_'):
+            if residue.get_resname() in dict_aa.keys():
+                return 1
+
+    def accept_atom(self,atom):
+        if not atom.is_disordered() or atom.get_altloc() == 'A':
+                if atom.element.strip() != 'H':
+                        return 1
+
+def change_atloc(pdbfile,
+                out=None):
+    if out == None:
+        out = (pdbfile.rsplit('.')[0]
+                + '_atm_loc'
+                + '.pdb')
+    
+    outfle = open(out,'w')
+    with open(pdbfile) as pdb:
+        for lne in pdb:
+            try:
+                if len(lne.split()[3]) >3:
+                    lne = lne.replace(lne.split()[3],' ' + lne.split()[3][1:])
+                elif len(lne.split()[2]) > 3:
+                    for keys in dict_aa.keys():
+                        if keys in lne.split()[2]:
+                            lne = lne.replace(lne.split()[2], lne.split()[2][0:3] + ' ' + lne.split()[2][4:])
+            except: pass
+            outfle.write(lne)
+    outfle.close()
+    return out
+
+def write_sel_pdb(pdbfile):
+    writer = PDBIO()
+    struct = str_object(pdbfile)
+    writer.set_structure(struct)
+    outfle = (pdbfile.rsplit('.',1)[0]
+                + '_clean'
+                + '.pdb')
+    writer.save(outfle, select=SelectResidues())
+
+    return outfle

fast_hint_ppi-0.1.3/Fast_HInt/script_pi_score/interface_assess.py

@@ -0,0 +1,154 @@
+#Adapted from interface_assess.py (https://gitlab.com/topf-lab/pi_score/-/tree/master/score_scripts)
+
+from Bio.PDB.MMCIFParser import MMCIFParser
+import sys
+from Bio.PDB import Selection, NeighborSearch, PDBParser, Select
+import json
+
+dict_aa = {'CYS': 'C', 'ASP': 'D', 'SER': 'S', 'GLN': 'Q', 'LYS': 'K',
+           'ILE': 'I', 'PRO': 'P', 'THR': 'T', 'PHE': 'F', 'ASN': 'N', 
+           'GLY': 'G', 'HIS': 'H', 'LEU': 'L', 'ARG': 'R', 'TRP': 'W', 
+           'ALA': 'A', 'VAL':'V', 'GLU': 'E', 'TYR': 'Y', 'MET': 'M'}
+
+class SelectChains(Select):
+    """ Only accept the specified chains when saving. """
+    def __init__(self, chain_letters):
+        self.chain_letters = chain_letters
+
+    def accept_chain(self, chain):
+        return (chain.get_id() in self.chain_letters)
+
+def str_object(pdbfile):
+    '''
+    Given a pdb file creates a structure object
+    '''
+    if pdbfile.rsplit('.')[-1] == 'pdb':
+        parser = PDBParser(QUIET=True)
+    elif pdbfile.rsplit('.')[-1] == 'ent':
+        parser = PDBParser(QUIET=True)
+    elif pdbfile.rsplit('.')[0] == 'cif':
+        parser = MMCIFParser()
+    else:
+        print 'Not a valid PDB format'
+        sys.exit()
+    structure = parser.get_structure('id', pdbfile)
+    return structure
+
+def get_num_chains(structure):
+    '''
+    Returns a list of chain objects in a structure
+    '''
+    ch_list = Selection.unfold_entities(structure, 'C')
+    return ch_list
+
+def get_CAatoms(chain_object):
+    '''
+    for a given chain object, returns a list of CA atoms
+    '''
+    ca_list = []
+    atm_list = Selection.unfold_entities(chain_object, 'A')
+    for a in atm_list:
+        if a.get_id() == 'CA':
+            ca_list.append(a)
+    return ca_list
+    
+def interface_residues(pdbfile,
+                    len_chains,
+                    numres_cut,
+                    dist_cutoff):
+    '''
+    Given a PDB file calculates interface residues
+    '''
+#     numres_cut = int(numres_cut)
+    structure = str_object(pdbfile)
+    ch_list = get_num_chains(structure)
+    int_reslist_j = []
+    int_reslist_i = []
+    dict_intf = {}
+    dict_residue_contacts = {}
+    for i in xrange(0,len(ch_list)-1):
+        for j in xrange(i+1,len(ch_list)):
+            int_reslist_j = []
+            int_reslist_i = []
+            intf_ch = ch_list[j].get_id() + '_' + ch_list[i].get_id()
+            ca_i = get_CAatoms(ch_list[i])
+            ca_j = get_CAatoms(ch_list[j])
+            # print ca_i, intf_ch
+            if len(ca_i) <len_chains or len(ca_j) <len_chains: 
+                # dict_intf = {} 
+                # dict_residue_contacts = {}
+                continue
+            ns_i = NeighborSearch(ca_i)
+            for atms in ca_j:
+                n = ns_i.search(atms.get_coord(), dist_cutoff,'R')
+                if len(n) >0 :
+                    res = (str(atms.get_parent().get_resname()) 
+                             + str(atms.get_parent().get_id()[1]))
+                    int_reslist_j.append(res)
+                    t = []
+                    for at in n:
+                        res1 = (str(at.get_resname()) 
+                             + str(at.get_id()[1]))
+                        int_reslist_i.append(res1)
+                        t.append(res1)
+                    if intf_ch in dict_residue_contacts.keys():  
+                        dict_residue_contacts[intf_ch].update({res:t})
+                    else:
+                        dict_residue_contacts[intf_ch] = {res:t}
+            #Number of interface residues from each chain is >=10
+            if len(set(int_reslist_j)) >= numres_cut and len(set(int_reslist_i)) >=numres_cut:
+                dict_intf[intf_ch] = [list(set(int_reslist_j)),list(set(int_reslist_i))]   
+    intf_outfle_prefix = pdbfile.split('.')[0]
+    intf_outfle_name = intf_outfle_prefix + '_interface_residues_dict.json'
+    
+    if dict_intf: 
+        with open(intf_outfle_name,'w') as outfle:
+            json.dump(dict_intf,outfle)
+    return dict_intf, dict_residue_contacts
+    
+    
+def polar_residues(reslist):
+    assert len(reslist) >0 
+    polar_ref = ['SER', 
+                 'THR',
+                 'ASN',
+                 'GLN',
+                 'HIS',
+                 'TYR']
+    polar_reslist = []
+    for r in reslist:
+        if r in polar_ref:
+            polar_reslist.append(r)
+    frac_polar_residue = len(polar_reslist)/float(len(reslist))
+    return frac_polar_residue
+
+def hydrophobic_residues(reslist):
+    assert len(reslist) >0 
+    hydro_ref = ['ALA',
+                 'LEU',
+                 'ILE',
+                 'VAL',
+                 'PHE',
+                 'TRP',
+                 'CYS',
+                 'MET'
+                ]
+    hydro_reslist = []
+    for r in reslist:
+        if r in hydro_ref:
+            hydro_reslist.append(r)
+    frac_hydro_residue = len(hydro_reslist)/float(len(reslist))
+    return frac_hydro_residue
+            
+def charged_residues(reslist):
+    assert len(reslist) >0 
+    charged_ref = ['LYS',
+                   'ARG',
+                   'ASP',
+                   'GLU']
+    charged_reslist = []
+    for r in reslist:
+        if r in charged_ref:
+            charged_reslist.append(r)
+    frac_charged_residue = len(charged_reslist)/float(len(reslist))
+    return frac_charged_residue

fast_hint_ppi-0.1.3/Fast_HInt/script_pi_score/pi_score_utils.py

@@ -0,0 +1,279 @@
+#Adapted from utils.py (https://gitlab.com/topf-lab/pi_score/-/tree/master/score_scripts)
+
+import os
+import json
+import pandas as pd
+import numpy as np
+import pickle
+import sys
+
+def write_csv_with_features_wc_2(indir,outfle):
+    out_csv = outfle
+    lst_features = ['Num_intf_residues', 'Polar', 'Hydrophobhic', 'Charged']
+    outfle = open(out_csv,'w')
+    #writing header in csv file
+    outfle.write('pdb,interface,')
+    for features in lst_features:
+        outfle.write(features + ',')
+    outfle.write('contact_pairs')
+    outfle.write(',sc,hb,sb,int_solv_en,int_area,pvalue')
+    outfle.write('\n')
+    for fle in os.listdir(indir):
+        if os.path.isdir(os.path.join(indir,fle)):
+            intf_dict = ''
+            cons = {}
+            pisa_dict = {}
+            dict_num_contacts = {}
+            sc_dict = {}
+
+            for j in os.listdir(os.path.join(indir,fle)):
+                nw_path = os.path.join(os.path.join(indir,fle),j)
+                if not os.path.isfile(nw_path):
+                    continue
+                if not nw_path.endswith('json'):
+                    continue
+
+                if nw_path.endswith('_interface_chain_contacts.json'):
+                    contacts_dict = nw_path
+                    dict_num_contacts = count_contacts_at_interface(contacts_dict)
+
+                elif nw_path.endswith('interface_properties_dict.json'):
+                    intf_dict = nw_path
+
+                elif nw_path.endswith('sc_scores.json'):
+                    sc_dict1 = nw_path
+                    with open(sc_dict1,'rb') as handle:
+                        sc_dict = json.load(handle)
+                elif nw_path.endswith('dict_pisa.json'):
+                    with open(nw_path) as handle:
+                        pisa_dict = json.load(handle)
+                if intf_dict:
+                    with open(intf_dict) as handle:
+                        dict_intf_prop = json.load(handle)
+                        for intf in dict_intf_prop:
+                            outfle.write(fle + ',' + intf + ',')
+                            for feature in lst_features:
+                                if feature == lst_features[0]:
+                                    outfle.write(str(dict_intf_prop[intf][feature]) + ',')
+                                else:
+                                    try:
+                                        outfle.write(str(round(dict_intf_prop[intf][feature],3)) + ',')
+                                    except:
+                                        outfle.write('NA' + ',')
+                            intf1 = intf.strip().split('_')[-1] + '_' + intf.strip().split('_')[0]
+                            if dict_num_contacts:
+                                outfle.write(str(dict_num_contacts[intf]) + ',')
+                            else:
+                                outfle.write('NA,')
+                            if sc_dict:
+                                for pdbid_sc in sc_dict.keys():
+                                    if intf in sc_dict[pdbid_sc].keys() and len(sc_dict[pdbid_sc][intf]) > 0:
+                                        outfle.write(str(sc_dict[pdbid_sc][intf]) + ',')
+                                    elif intf1 in sc_dict[pdbid_sc].keys() and len(sc_dict[pdbid_sc][intf1]) > 0:
+                                        outfle.write(str(sc_dict[pdbid_sc][intf1]) + ',')
+                                    else:
+                                        outfle.write('NA,')
+                            else:
+                                outfle.write('NA,')
+
+                            if pisa_dict:
+                                k = ''
+                                if intf in pisa_dict.keys():
+                                    k = intf
+                                elif intf1 in pisa_dict.keys():
+                                    k = intf1
+                                if k:
+                                    try:
+                                        outfle.write(str(pisa_dict[k]['hb']) + ',')
+                                    except:
+                                        outfle.write('NA,')
+                                    try:
+                                        outfle.write(str(pisa_dict[k]['sb']) + ',')
+                                    except:
+                                        outfle.write('NA,')
+                                    try:
+                                        outfle.write(str(pisa_dict[k]['int_solv_en']) + ',')
+                                    except:
+                                        outfle.write('NA,')
+                                    try:
+                                        outfle.write(str(pisa_dict[k]['int_area']) + ',')
+                                    except:
+                                        outfle.write('NA,')
+                                    try:
+                                        outfle.write(str(pisa_dict[k]['pvalue']))
+                                    except:
+                                        outfle.write('NA')
+                                else:
+                                    outfle.write('NA,NA,NA,NA,NA')
+                            outfle.write('\n')
+    outfle.close()
+
+def write_csv_with_features_wc(indir,outfle):
+    out_csv = outfle
+    lst_json_fles = []
+    lst_features = ['Num_intf_residues', 'Polar', 'Hydrophobhic', 'Charged']
+    outfle = open(out_csv,'w')
+    #writing header in csv file
+    outfle.write('pdb,interface,')
+    for features in lst_features:
+        outfle.write(features + ',')
+    outfle.write('contact_pairs')
+    outfle.write(', sc, hb, sb, int_solv_en, int_area, pvalue')
+    outfle.write('\n')
+    for fle in os.listdir(indir):
+        if os.path.isdir(os.path.join(indir,fle)):
+            intf_dict = ''
+            cons = {}
+            pisa_dict = {}
+            dict_num_contacts = {}
+            complete_sc_dict = {}
+
+            for j in os.listdir(os.path.join(indir,fle)):
+                nw_path = os.path.join(os.path.join(indir,fle),j)
+                if not os.path.isfile(nw_path):
+                    continue
+                if not nw_path.endswith('json'):
+                    continue
+
+                if nw_path.endswith('_interface_chain_contacts.json'):
+                    contacts_dict = nw_path
+                    dict_num_contacts = count_contacts_at_interface(contacts_dict)
+
+                elif nw_path.endswith('interface_properties_dict.json'):
+                    intf_dict = nw_path
+
+                elif nw_path.endswith('sc_scores.json'):
+                    with open(nw_path,'rb') as handle:
+                        sc_dict = json.load(handle)
+                        for pdbid, intf_dict_sc in sc_dict.items():
+                            if pdbid not in complete_sc_dict:
+                                complete_sc_dict[pdbid] = {}
+                            complete_sc_dict[pdbid].update(intf_dict_sc)
+
+                elif nw_path.endswith('dict_pisa.json'):
+                    with open(nw_path) as handle:
+                        pisa_dict = json.load(handle)
+
+            if intf_dict:
+                with open(intf_dict) as handle:
+                    dict_intf_prop = json.load(handle)
+                    for intf in dict_intf_prop:
+                        outfle.write(fle + ',' + intf + ',')
+                        for feature in lst_features:
+                            if feature == lst_features[0]:
+                                outfle.write(str(dict_intf_prop[intf][feature]) + ',')
+                            else:
+                                try:
+                                    outfle.write(str(round(dict_intf_prop[intf][feature],3)) + ',')
+                                except:
+                                    outfle.write('NA' + ',')
+                        #if cons:
+                        #    try:
+                        #        outfle.write(str(round(cons[intf],3)) + ',')
+                        #    except:
+                        #        outfle.write('NA'+ ',')
+                        #else:
+                        #   outfle.write('NA'+ ',')
+                        intf1 = intf.strip().split('_')[-1] + '_' + intf.strip().split('_')[0]
+                        if dict_num_contacts:
+                            outfle.write(str(dict_num_contacts[intf]) + ',')
+                        else:
+                            outfle.write('NA,')
+                        sc_val = 'NA'
+                        for pdbid_sc, intf_sc_dict in complete_sc_dict.items():
+                            if intf in intf_sc_dict:
+                                sc_val = intf_sc_dict[intf]
+                                break
+                            elif intf1 in intf_sc_dict:
+                                sc_val = intf_sc_dict[intf1]
+                                break
+                        outfle.write(sc_val+",")
+
+                        if pisa_dict:
+                            k = ''
+                            if intf in pisa_dict.keys():
+                                k = intf
+                            elif intf1 in pisa_dict.keys():
+                                k = intf1
+                            if k:
+                                try:
+                                    outfle.write(str(pisa_dict[k]['hb']) + ',')
+                                except:
+                                    outfle.write('NA,')
+                                try:
+                                    outfle.write(str(pisa_dict[k]['sb']) + ',')
+                                except:
+                                    outfle.write('NA,')
+                                try:
+                                    outfle.write(str(pisa_dict[k]['int_solv_en']) + ',')
+                                except:
+                                    outfle.write('NA,')
+                                try:
+                                    outfle.write(str(pisa_dict[k]['int_area']) + ',')
+                                except:
+                                    outfle.write('NA,')
+                                try:
+                                    outfle.write(str(pisa_dict[k]['pvalue']))
+                                except:
+                                    outfle.write('NA')
+                            else:
+                                outfle.write('NA,NA,NA,NA,NA')
+                        outfle.write('\n')
+
+
+def count_contacts_at_interface(contacts_dict):
+    dict_num_contacts = {}
+    with open(contacts_dict,'rb') as handle:
+        dict_contacts = json.load(handle)
+    #print dict_contacts
+    for intf_name in dict_contacts:
+        ct = 0
+        for ch1_res in dict_contacts[intf_name].keys():
+            for ch2_res in dict_contacts[intf_name][ch1_res]:
+                ct += 1
+        dict_num_contacts[intf_name] = ct
+    return dict_num_contacts
+
+def filter_csv(csvfile,outfile):
+    '''
+    Takes the CSV file as input and does a sanity check that all features are computed
+    '''
+    if os.path.isfile(outfile):
+        os.remove(outfile)
+    out = open(outfile,'w')
+    with open(csvfile,'r') as infile:
+        for lne in infile:
+            if 'NA' not in lne:
+                out.write(lne)
+    out.close() 
+
+def make_predictions(saved_sc, csvfile, saved_model, outfle, session_id):
+    with open(saved_model,'rb') as file:
+        clf_m = pickle.load(file)
+
+    topredict = pd.read_csv(csvfile)
+    if topredict.empty:
+        print 'All features could not be calculated successfully for atleast one of the interfaces!'
+        print 'Exiting'
+        sys.exit(1)
+    topredict_1 = topredict.drop(['pdb','interface','Num_intf_residues'], axis=1)
+    with open(saved_sc, 'rb') as file:
+        sc = pickle.load(file)
+        topredict_1 = np.nan_to_num(sc.transform(topredict_1))
+    
+    pred_em = clf_m.predict(topredict_1)
+    dec = clf_m.decision_function(topredict_1)
+
+    out = open(outfle, 'w')
+    out.write('#PDB,chains,predicted_class,pi_score\n')
+
+
+    pdb_em = topredict['pdb']
+    pdb_em_int = topredict['interface']
+
+    for i in range(len(topredict_1)):
+        out.write(str(pdb_em[i]) + ',' +
+                  str(pdb_em_int[i]) + ',' +
+                  str(pred_em[i]) + ',' +
+                  str(round(dec[i],2)) + '\n')
+    out.close()

fast_hint_ppi-0.1.3/Fast_HInt/script_pi_score/pisa_utils.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+#Adapted from pisa_utils.py (https://gitlab.com/topf-lab/pi_score/-/tree/master/score_scripts)
+
+import json
+import uuid
+import subprocess
+
+def run_pisa(pdbfile=None):
+    assert pdbfile is not None
+    
+    session_id = uuid.uuid4().hex[:8]
+    outfle = pdbfile.rsplit('.pdb',1)[0] + '_pisa_' + session_id + '.xml'
+    
+    # lancer pisa avec session unique
+    cmds = [
+        'pisa %s -analyse %s' % (session_id, pdbfile),
+        'pisa %s -xml interfaces > %s' % (session_id, outfle),
+        'pisa %s -erase' % (session_id)
+    ]
+
+    for i, cmd in enumerate(cmds):
+        proc = subprocess.Popen(cmd, shell=True, stderr=subprocess.STDOUT,close_fds=True)
+        proc.wait() 
+    return outfle
+
+
+def parse_pisa_xml_outfle(xml_fle,outfle_name=None):
+    import xml.etree.ElementTree as ET
+    intf_area = ''
+    pvalue = ''
+    energy = ''
+    hb = ''
+    sb = ''
+    dict_pisa = {}
+    if outfle_name == None:
+        outfle_name = xml_fle.split('_pisa')[0] + '_dict_pisa.json'
+    try:
+        root = ET.parse(xml_fle).getroot()
+        for interface in root.findall('interface'):
+            intf_ch = []
+            intf_area = "%.2f" % float(interface.find('int_area').text)
+            pvalue = "%.2f" % float(interface.find('pvalue').text)
+            energy = "%.2f" % float(interface.find('int_solv_en').text)
+            for mol in interface.findall('molecule'):
+                mol1 = mol.find('chain_id').text
+                intf_ch.append(mol1)
+            intf_chains = '_'.join(intf_ch)
+            dict_pisa[intf_chains] = {}
+            for hbonds in interface.findall('h-bonds'):
+                hb = int(hbonds.find('n_bonds').text)
+            for sb in interface.findall('salt-bridges'):
+                sb = int(sb.find('n_bonds').text)
+            dict_pisa[intf_chains]['int_area'] = intf_area
+            dict_pisa[intf_chains]['pvalue'] = pvalue
+            dict_pisa[intf_chains]['int_solv_en'] = energy
+            dict_pisa[intf_chains]['hb'] = hb
+            dict_pisa[intf_chains]['sb'] = sb
+    except:
+        root = []
+        pass
+    if dict_pisa:
+        with open(outfle_name,'w') as outfle:
+            json.dump(dict_pisa,outfle)
+    return dict_pisa

fast_hint_ppi-0.1.3/Fast_HInt/script_pi_score/run_piscore_wc.py

@@ -0,0 +1,214 @@
+#Adapted from run_piscore_wc.py (https://gitlab.com/topf-lab/pi_score/-/tree/master/score_scripts)
+#code in python 2.7
+import argparse
+import os
+import shutil
+from interface_assess import *
+from sc_utils import write_sc_script, run_sc
+from clean_pdb import write_sel_pdb, change_atloc
+from pisa_utils import run_pisa, parse_pisa_xml_outfle
+from pi_score_utils import write_csv_with_features_wc, make_predictions, filter_csv
+import time
+import sys
+import uuid 
+
+author = 'Author: Sony Malhotra '
+
+
+parser = argparse.ArgumentParser(description="Calculate PI-score for a given complex structure")
+group = parser.add_mutually_exclusive_group(required=True)
+group.add_argument("-p", "--pdb", help="PDB file to calculate the PI-score", default=None)
+group.add_argument("-d", "--dirc", help="directory to assess the PDB files",default=None)
+parser.add_argument("-ch", "--chains", help="Chains forming the interface which needs to be assessed",default=None)
+parser.add_argument("-dc", "--distance_cutoff", help="Distance cutoff for interface definition",default=7, type =float)
+parser.add_argument("-s", "--intf_size", help="Number of interface residues from each of the interacting subunits",default=10,type=int)
+parser.add_argument("-ps", "--prot_size", help="Length of each of the chains",default=30,type=int)
+parser.add_argument("-np", "--num_processors", help="Number of processors to use",default=40,type=int)
+parser.add_argument("-o", "--out", help="Name of the output directory to write results",default=os.path.join(os.getcwd(),'pi_output'))
+parser.add_argument("-c","--csv",help="Name of the CSV files where features will be stored",default=None)
+parser.add_argument("-m","--model",help="SVM model to make new predictions",choices=['A','B','WC'], default='WC')
+parser.add_argument("-r","--results",help="Name of the file where model predictions will be written",default=None)
+
+def main(): 
+    args = parser.parse_args()
+    pdblist = []
+    
+    if args.dirc != None:
+        #print ('Setting chains to all chains')
+        args.chains = None
+
+    #print ('*****Selecting model for training*****')
+    dirname, filename = os.path.split(os.path.abspath(__file__))
+    if args.model == 'A':
+        saved_model = os.path.join(os.path.dirname(sys.argv[0]),'svm_model/finalized_model_A.sav')
+        saved_sc = os.path.join(dirname,'svm_model/scaler_model_A.sav')
+    elif args.model == 'B':
+        saved_model = os.path.join(os.path.dirname(sys.argv[0]),'svm_model/finalized_model_B.sav')
+        saved_sc = os.path.join(dirname,'svm_model/scaler_model_B.sav')
+    if args.model == 'WC':
+        saved_model = os.path.join(os.path.dirname(sys.argv[0]),'svm_model/finalized_model_wc.sav')
+        saved_sc = os.path.join(dirname,'svm_model/scaler_model_wc.sav')
+    working_path = os.getcwd()
+
+    #print ('*****Setting output directory for results*****')
+    if not os.path.isdir(args.out):
+        os.mkdir(args.out)
+
+    session_id = uuid.uuid4().hex[:8]
+
+    if args.csv is None:
+        current_time = time.strftime("%m.%d.%y_%H%M", time.localtime())
+        obj = session_id
+        args.csv = os.path.join(args.out, "intf_features_%s_%s.csv" % (current_time, session_id))
+        
+    if args.results is None:
+        current_time = time.strftime("%m.%d.%y_%H%M", time.localtime())
+        args.results = os.path.join(args.out,"pi_score_%s_%s_id.txt" % (current_time, session_id))
+    
+    if os.path.isfile(args.results):
+        os.remove(args.results)
+    
+    out = open(args.results,'w')
+    out.write('#PDB,chains,predicted_class,pi_score\n')
+    out.close()
+    
+    filter_csvfle = os.path.join(args.out,"filter_intf_features_%s_%s.csv" % (current_time, session_id))
+
+    #print ('*****Setting input for assessment*****')
+    #get a list of pdbfiles to score interfaces for
+    if args.pdb:
+        pdblist = [args.pdb.rsplit('/',1)[-1]]
+    elif args.dirc:
+        for fl in os.listdir(args.dirc):
+            if fl.endswith('pdb'):
+                pdblist.append(fl)
+    else:
+        print ('Not a valid input')
+
+
+    #list of directories where to run conservation
+    #dir_infiles = []
+    #all_conslst = []
+    #all_consdir = []
+    #ch_lst = []
+
+    #print ('*****Iterating over each structure to assess*****')
+    for pdb in pdblist:
+        chains_in = []
+        os.chdir(working_path)
+        pd = pdb.rsplit('.',1)[0]
+        #make an output directory
+        if os.path.isdir(os.path.join(args.out,pd)):
+            shutil.rmtree(os.path.join(args.out,pd))
+        #print ('*****Making results subdirectory specific to each structure in output directory*****')
+        #print (os.path.join(args.out,pd))
+        os.mkdir(os.path.join(args.out,pd))
+        #copy input files
+        if args.dirc:
+            copy_cmd = 'cp '+ os.path.join(args.dirc,pdb) + ' ' + os.path.join(args.out,pd)
+        else:
+            copy_cmd = 'cp '+ os.path.join(args.pdb) + ' ' + os.path.join(args.out,pd)
+        #print ('*****Doing PDB,',pdb,' *****')
+        os.system(copy_cmd)
+        os.chdir(os.path.join(args.out,pd))
+        #print ('*****Calculating interface*****')
+        #Interface calculation
+        dict_intf,dict_contact = interface_residues(pdb,
+                                                    len_chains=args.prot_size,
+                                                    numres_cut=args.intf_size,
+                                                    dist_cutoff=args.distance_cutoff)
+        intf_outfle_prefix = pd
+        if not dict_intf: 
+            intf_outfle_name = intf_outfle_prefix + '_no_int.txt'
+            a = open(intf_outfle_name,'w')
+            a.write('No interfaces found')
+            a.close()
+            continue
+        
+        #print ('*****Calculating contacts*****')
+        #Writing the contact dictionary, which residue from which chains are in contact
+        contact_name = intf_outfle_prefix + '_interface_chain_contacts.json'
+        with open(contact_name,'w') as outfle:
+            json.dump(dict_contact,outfle)
+        if args.chains:
+            for c in args.chain:
+                chains_in.append(c)
+        dict_intf_prop = {}
+        
+        #Write clean pdbfile for shape complementarity
+        clean_pdbfile = write_sel_pdb(pdb)
+        atm_file = change_atloc(clean_pdbfile)
+        os.system('rm -f ' + clean_pdbfile)
+        os.system('mv ' + atm_file + ' ' + clean_pdbfile)
+        
+        #print ('*****Iterating over interfaces in structure*****')
+        #Iterating over all the interfaces
+        index = 0
+        for k in dict_intf:
+            index+=1
+            ch1 = k.split('_')[0]
+            ch2 = k.split('_')[-1]
+            flag = False
+            if args.chains:
+                if ch1 in args.chains and ch2 in args.chains:
+                    flag = True
+                    break
+                else:
+                    print ('No interfaces between the input chains,', args.chains)
+                    continue
+            #print ('*****Calculating interface features*****')
+            if flag or not args.chains: 
+                ch1_intf_res = dict_intf[k][0]
+                ch2_intf_res = dict_intf[k][1]
+                dict_intf_prop[k] = {'Intfresidues_ch1':[ch1,len(ch1_intf_res)]}
+                dict_intf_prop[k] = {'Intfresidues_ch2':[ch2,len(ch2_intf_res)]}
+                total_intf_res = ch1_intf_res + ch2_intf_res
+                total_num_intf_res = len(total_intf_res)
+                only_res_name_lst = []
+                for re in total_intf_res:
+                    only_res_name_lst.append(re[0:3])
+                polar = polar_residues(only_res_name_lst)
+                hydro = hydrophobic_residues(only_res_name_lst)
+                charged = charged_residues(only_res_name_lst)
+                if dict_intf_prop[k]:
+                    dict_intf_prop[k].update({'Polar':polar, 'Charged': charged, 'Hydrophobhic':hydro, 'Num_intf_residues': total_num_intf_res})
+                else:
+                    dict_intf_prop[k] = {'Polar':polar, 'Charged': charged, 'Hydrophobhic':hydro, 'Num_intf_residues': total_num_intf_res}
+                intf_outfle_name = intf_outfle_prefix + '_interface_properties_dict.json'
+                with open(intf_outfle_name,'w') as outfle:
+                    json.dump(dict_intf_prop,outfle)     
+
+                #print ('*****Calculating shape complementarity*****')
+                #calculate shape complementarity
+                scriptfile = write_sc_script(chain_lst=k.split('_'),
+                                            pdbfile=clean_pdbfile)
+                sc_dir = args.out+"/"+pd+"/"+scriptfile
+                run_sc(sc_dir)
+                #parse_sc_output('tmp_sc.out')
+                
+        #print ('*****Calculating pisa *****')
+        #calculate features using pisa
+        outfle_name = run_pisa(clean_pdbfile)
+        pisa_out = parse_pisa_xml_outfle(outfle_name)
+
+    os.chdir(working_path)
+
+    #print ('*****Writing CSV file with features *****')
+    # # Write the CSV file with interface features
+    
+    write_csv_with_features_wc(indir=args.out, outfle=args.csv)
+    # 
+    # 
+    # #filter CSV and have only interfaces where all features were computed successfully
+    filter_csv(args.csv,filter_csvfle)
+
+    #print ('*****Calculating PI-score*****')
+    # # #Make predictions
+    make_predictions(saved_sc=saved_sc, 
+                    csvfile=filter_csvfle, 
+                    saved_model=saved_model,
+                    outfle=args.results,
+                    session_id=session_id)
+if __name__ == '__main__':
+    main()
+

fast_hint_ppi-0.1.3/Fast_HInt/script_pi_score/sc_utils.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+#Adapted from sc_utils.py (https://gitlab.com/topf-lab/pi_score/-/tree/master/score_scripts)
+import os
+import json
+import uuid
+import subprocess
+
+def write_sc_script(pdbfile,
+                    chain_lst=None,
+                    outfle=None,
+                    ):
+    '''
+    chain_lst should be list of only two chain Ids e.g. [A,B]
+    '''
+    #print ('Writing sc script', chain_lst)
+    assert (chain_lst != None),"Input chain ID list!"
+    assert len(chain_lst) == 2, "Input list with only two chain IDs e.g [A,B]"
+    if outfle == None:
+        outfle = pdbfile + '_' + '_'.join(chain_lst) + '_sc_infle.sh'
+    #print (outfle, 'OUTFLE for SC')
+    out = open(outfle,'w')
+    out.write('#!/bin/bash\n')
+    out.write('sc XYZIN ' + pdbfile + ' <<eof \n')
+    out.write('MOLECULE 1\nCHAIN ' + chain_lst[0] + '\n' + 'MOLECULE 2\nCHAIN ' + chain_lst[1] + '\nEND\neof')
+    out.close()
+    os.system('chmod 777 ' + outfle)
+    return outfle
+
+def run_sc(scriptfile):
+    session_id = uuid.uuid4().hex[:8]
+    unique_script = "%s_%s.sh" % (scriptfile.rsplit('.', 1)[0], session_id)
+    tmp_out = "%s_tmp_sc_%s.out" % (scriptfile.rsplit('.', 1)[0], session_id)
+
+    subprocess.call(["cp", scriptfile, unique_script])
+    subprocess.call(["sed", "-i", "s/session name/session_%s/g" % session_id, unique_script])
+
+
+
+    with open(tmp_out, "w") as out_fh:
+        proc = subprocess.Popen([unique_script], stdout=out_fh, stderr=subprocess.STDOUT, close_fds=True)
+        proc.wait()
+
+    os.remove(unique_script)
+    parse_sc_output(tmp_out)
+
+def parse_sc_output(outfle):
+    new_name = outfle.rsplit('_tmp_sc.out',1)[0] + '_dict_sc_scores.json'
+    if os.path.isfile(new_name):
+        with open(new_name) as json_file:
+            dict_out = json.load(json_file)
+    #else:
+    dict_out = {}
+    ch_lst = []
+    pdb = ''
+    sc = ''
+    #print(outfle)
+    with open(outfle,'r') as out:
+        for lne in out:
+            if 'Number of atoms selected in chain' in lne:
+                ch_lst.append(lne.split('=')[0].split()[-1])
+            if 'Logical name: XYZIN  File name: ' in lne:
+                #pdb = lne.split()[-1][0:4]
+                #for em challenge targets
+                pdb = lne.split()[-1].split('_clean')[0]
+
+            if 'Shape complementarity statistic Sc' in lne:
+                sc = lne.split('=')[-1].strip()
+        try:
+            if pdb in dict_out.keys():
+                dict_out[pdb].update({'_'.join(ch_lst):sc})
+            else:
+                dict_out[pdb] = {'_'.join(ch_lst):sc}
+        except:
+            pass
+
+        with open(new_name,'w') as sec_outfle:
+            json.dump(dict_out,sec_outfle)
+
+
+
+

fast_hint_ppi-0.1.3/Fast_HInt/script_pi_score/svm_model/__init__.py

@@ -0,0 +1 @@
+"""svm_weight"""

{fast_hint_ppi-0.1.2 → fast_hint_ppi-0.1.3}/Fast_HInt_ppi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Fast_HInt-ppi
-Version: 0.1.2
+Version: 0.1.3
 Summary: A tool to find homologous interactions and speed up AlphaFold-based structural modeling.
 Home-page: https://github.com/Qrouger/HInt
 Author: Quentin Rouger

fast_hint_ppi-0.1.3/Fast_HInt_ppi.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+README.md
+setup.py
+Fast_HInt/Fast_HInt.py
+Fast_HInt/File_proteins.py
+Fast_HInt/Scoring_HInt.py
+Fast_HInt/Utils_HInt.py
+Fast_HInt/__init__.py
+Fast_HInt/get_good_inter_pae.py
+Fast_HInt/script_pi_score/__init__.py
+Fast_HInt/script_pi_score/calculate_mpdockq.py
+Fast_HInt/script_pi_score/clean_pdb.py
+Fast_HInt/script_pi_score/interface_assess.py
+Fast_HInt/script_pi_score/pi_score_utils.py
+Fast_HInt/script_pi_score/pisa_utils.py
+Fast_HInt/script_pi_score/run_piscore_wc.py
+Fast_HInt/script_pi_score/sc_utils.py
+Fast_HInt/script_pi_score/svm_model/__init__.py
+Fast_HInt_ppi.egg-info/PKG-INFO
+Fast_HInt_ppi.egg-info/SOURCES.txt
+Fast_HInt_ppi.egg-info/dependency_links.txt
+Fast_HInt_ppi.egg-info/entry_points.txt
+Fast_HInt_ppi.egg-info/requires.txt
+Fast_HInt_ppi.egg-info/top_level.txt

{fast_hint_ppi-0.1.2 → fast_hint_ppi-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Fast_HInt-ppi
-Version: 0.1.2
+Version: 0.1.3
 Summary: A tool to find homologous interactions and speed up AlphaFold-based structural modeling.
 Home-page: https://github.com/Qrouger/HInt
 Author: Quentin Rouger

{fast_hint_ppi-0.1.2 → fast_hint_ppi-0.1.3}/setup.py

@@ -4,7 +4,7 @@ from setuptools import setup
 
 setup(
     name='Fast_HInt-ppi',
-    version='0.1.2',
+    version='0.1.3',
     description=(
         'A tool to find homologous interactions and speed up AlphaFold-based structural modeling.'
     ),

fast_hint_ppi-0.1.2/Fast_HInt_ppi.egg-info/SOURCES.txt

@@ -1,14 +0,0 @@
-README.md
-setup.py
-Fast_HInt/Fast_HInt.py
-Fast_HInt/File_proteins.py
-Fast_HInt/Scoring_HInt.py
-Fast_HInt/Utils_HInt.py
-Fast_HInt/__init__.py
-Fast_HInt/get_good_inter_pae.py
-Fast_HInt_ppi.egg-info/PKG-INFO
-Fast_HInt_ppi.egg-info/SOURCES.txt
-Fast_HInt_ppi.egg-info/dependency_links.txt
-Fast_HInt_ppi.egg-info/entry_points.txt
-Fast_HInt_ppi.egg-info/requires.txt
-Fast_HInt_ppi.egg-info/top_level.txt