code/alphafold_featureVector.py

# IMPORT NECESSARY MODULES AND LIBRARIES
from timeit import default_timer as timer
import xml.etree.ElementTree as ET
from collections import Counter
from bs4 import BeautifulSoup
from io import StringIO
from decimal import *
import pandas as pd
import requests as r
import os.path as op
from pathlib import Path
import subprocess
import argparse
import ssbio.utils
import warnings
import sys
import pathlib
import os, glob
import math
import ssbio
import ssl
import gzip
import ast
import itertools

from Bio.Align import substitution_matrices
from Bio.PDB.Polypeptide import *
from Bio.PDB import PDBList
from Bio import Align
from Bio import SeqIO
from Bio.PDB import *
import numpy as np




# FUNCTIONS
from calc_pc_property import *
from add_domains import *
from add_annotations import *
from add_structure import *
from add_alignment import *
from manage_files import *
from add_3Dalignment import *
from add_sasa import *
from standard import *
from add_interface_pos import *
from standard import *
from uniprotSequenceMatch import uniprotSequenceMatch
from process_input import clean_data
from alphafold_model import *


def alphafold(input_set, mode, impute):
    start = timer()
    # Necessary lists
    annotation_list = ['disulfide', 'intMet', 'intramembrane', 'naturalVariant', 'dnaBinding', 'activeSite',
                       'nucleotideBinding', 'lipidation', 'site', 'transmembrane', 'crosslink', 'mutagenesis', 'strand',
                       'helix', 'turn', 'metalBinding', 'repeat', 'topologicalDomain', 'caBinding', 'bindingSite',
                       'region',
                       'signalPeptide', 'modifiedResidue', 'zincFinger', 'motif', 'coiledCoil', 'peptide',
                       'transitPeptide', 'glycosylation', 'propeptide']

    change_names = {'Disulfide bond': 'disulfide', 'Initiator methionine': 'intMet',
                    'Natural variant': 'naturalVariant',
                    'DNA binding': 'dnaBinding',
                    'Active site': 'activeSite', 'Nucleotide binding': 'nucleotideBinding', 'Lipidation': 'lipidation',
                    'Site': 'site', 'Transmembrane': 'transmembrane', 'Cross-link': 'crosslink',
                    'Mutagenesis': 'mutagenesis', 'Beta strand': 'strand', 'Helix': 'helix', 'Turn': 'turn',
                    'Metal binding': 'metalBinding', 'Repeat': 'repeat',
                    'Topological domain': 'topologicalDomain', 'Calcium binding': 'caBinding',
                    'Binding site': 'bindingSite',
                    'Region': 'region', 'Signal peptide': 'signalPeptide', 'Modified residue': 'modifiedResidue',
                    'Zinc finger': 'zincFinger', 'Motif': 'motif', 'Coiled coil': 'coiledCoil', 'Peptide': 'peptide',
                    'Transit peptide': 'transitPeptide', 'Glycosylation': 'glycosylation', 'Propeptide': 'propeptide',
                    'Intramembrane': 'intramembrane'}


    ## Standardizing input
    data = clean_data(input_set)

    path_to_input_files, path_to_output_files, path_to_domains, fisher_path, path_to_interfaces, alphafold_path, alphafold_summary= manage_files(mode)
    out_path = path_to_output_files / 'log.txt'
    sys.stdout = open(out_path, 'w')
    print('Creating directories...')
    file_base = str(Path(alphafold_path / '*'))
    file_str = glob.glob(file_base)[0].split('-')[-1].split('.')[0]
    ## Physicochemical properties
    print('Adding physicochemical properties...\n')
    data = add_physicochemical(data)

    ## Domains
    print('Adding domains\n')
    data = add_domains(data, path_to_domains)

    ## Processing data frame
    data = data.astype(str)
    data = data.replace({'NaN': np.NaN, 'nan': np.NaN})
    data.domain = data.domain.replace({np.NaN: '-1'})  # Fill -1 if NaN - standardization.
    data.domStart = data.domStart.replace({np.NaN: '-1'})
    data.domEnd = data.domEnd.replace({np.NaN: '-1'})
    data.distance = data.distance.replace({np.NaN: '-1'})
    fisherResult = pd.read_csv(fisher_path, sep='\t')
    significant_domains = fisherResult.domain.to_list()

    data = data.reset_index()
    data = data.drop(columns=['index'])

    ## not_match_in_uniprot : Data points not matched to UniProt sequence
    ## uniprot_matched: Data points matched to UniProt sequence. Proceed with this data frame
    ## canonical_fasta : Dataframe including canonical sequence for the protein of interest. Obtained from UniProt.
    ## isoform_fasta: Dataframe including isoform sequences for the protein of interest. Obtained from UniProt.
    not_match_in_uniprot, uniprot_matched, canonical_fasta, isoform_fasta = uniprotSequenceMatch(data)

    not_match_in_uniprot = not_match_in_uniprot.reset_index().drop(['index'], axis=1)

    for key in change_names.keys():
        not_match_in_uniprot[key] = ''
    not_match_in_uniprot = not_match_in_uniprot.rename(columns=change_names)
    uniprot_matched = add_annotations(uniprot_matched)

    for w in uniprot_matched.index:
        for q in annotation_list:
            per_protein = []
            if uniprot_matched.at[w, q] != 'nan':
                fix = ast.literal_eval(uniprot_matched.at[w, q])
                for z in fix:
                    if '-' in z:
                        per_protein += np.arange(int(z.split('-')[0]), int(z.split('-')[1])+1,1).tolist()
                    else:
                        try:
                            per_protein.append(int(z))
                        except:
                            ValueError
                uniprot_matched.at[w, q] = per_protein
            else:
                uniprot_matched.at[w, q] = 'nan'
    uniprot_matched = uniprot_matched.rename(columns=change_names)
    uniprot_matched['wt_sequence_match'] = uniprot_matched['wt_sequence_match'].astype(str)


    ## Avoiding downloading files for SASA calculation if already downloaded.

    existing_free_sasa = list(Path(path_to_output_files / 'freesasa_files').glob("*"))
    existing_free_sasa = [str(i) for i in existing_free_sasa]
    existing_free_sasa = [i.split('/')[-1].split('.')[0] for i in existing_free_sasa]
    ## Decide if the wild type amino acid is on canonical or isoform sequence. Selected sequence will be used for the
    ## sequence alignment.
    for i in uniprot_matched.index:
        if len(uniprot_matched.at[i, 'uniprotSequence']) >= int(uniprot_matched.at[i, 'pos']):
            wt = uniprot_matched.at[i, 'wt']
            can = str(uniprot_matched.at[i, 'uniprotSequence'])[int(uniprot_matched.at[i, 'pos']) - 1]
            if wt == can:
                uniprot_matched.at[i, 'wt_sequence_match'] = 'm'
            elif wt != can:
                isoList = isoform_fasta[
                    isoform_fasta['uniprotID'] == uniprot_matched.at[i, 'uniprotID']].isoformSequence.to_list()
                for k in isoList:
                    if len(k) >= int(uniprot_matched.at[i, 'pos']):
                        resInIso = k[int(int(uniprot_matched.at[i, 'pos']) - 1)]
                        if wt == resInIso:
                            whichIsoform = isoform_fasta[isoform_fasta.isoformSequence == k].whichIsoform.to_list()[0]
                            uniprot_matched.at[i, 'wt_sequence_match'] = 'i'
                            uniprot_matched.at[i, 'whichIsoform'] = whichIsoform
                            break

        elif len(uniprot_matched.at[i, 'uniprotSequence']) < int(uniprot_matched.at[i, 'pos']):
            isoList = isoform_fasta[
                isoform_fasta['uniprotID'] == uniprot_matched.at[i, 'uniprotID']].isoformSequence.to_list()
            for k in isoList:
                if len(k) >= int(uniprot_matched.at[i, 'pos']):
                    resInIso = k[int(int(uniprot_matched.at[i, 'pos']) - 1)]
                    wt = uniprot_matched.at[i, 'wt']
                    if wt == resInIso:
                        whichIsoform = isoform_fasta[isoform_fasta.isoformSequence == k].whichIsoform.to_list()[0]
                        uniprot_matched.at[i, 'wt_sequence_match'] = 'i'
                        uniprot_matched.at[i, 'whichIsoform'] = whichIsoform
                        break



    uniprot_matched = uniprot_matched.replace({'nan': np.NaN})
    for annot in ['Domain', 'Alternative sequence', 'Chain', 'Sequence conflict', 'Compositional bias']:
        try:
            uniprot_matched = uniprot_matched.drop(columns=annot)
        except:
            KeyError

    print('You have %d data points that failed to match a UniProt Sequence\nProceeding with %d remaining...\n'
          % (len(not_match_in_uniprot.drop_duplicates(['datapoint'])),
             len(uniprot_matched.drop_duplicates(['datapoint']))))

    ## Adding interface residue information.

    data_interface = pd.read_csv(path_to_interfaces, sep='\t')
    interface_positions = get_interface_positions(data_interface, 'P1', 'P2')

    interface_dataframe = pd.DataFrame()
    for key, val in interface_positions.items():
        k = pd.Series((key, str(list(set(val)))))
        interface_dataframe = interface_dataframe.append(k, ignore_index=True)
    interface_dataframe.columns = ['uniprotID', 'interface_positions']

    uniprot_matched = uniprot_matched.merge(interface_dataframe, on='uniprotID', how='left')
    uniprot_matched.interface_positions = uniprot_matched.interface_positions.astype('str')

    ## PDB info file is pre-generated for time concerns. Includes summary data of AlphaFold structures.
    ## With new updates, can be updated separately.

    pdb_info = pd.read_csv(alphafold_summary, sep='\t')

    ## Keeping how many models each AlphaFold structure has.
    model_count = modelCount(alphafold_path)
    for k, v in model_count.items():
        model_count[k] = int(v / 2)  # two types of files for each file.
    uniprot_matched = uniprot_matched.astype(str)
    uniprot_matched.domStart = uniprot_matched.domStart.astype(float)
    uniprot_matched.domEnd = uniprot_matched.domEnd.astype(float)
    uniprot_matched.domStart = uniprot_matched.domStart.astype(int)
    uniprot_matched.domEnd = uniprot_matched.domEnd.astype(int)



    ## Main part to add annotation information, align sequences, finding distances

    for i in uniprot_matched.index:
        print('Processing', i, 'of', len(uniprot_matched))
        if len(uniprot_matched.at[i, 'uniprotSequence']) >= int(uniprot_matched.at[i, 'pos']):
            wt = uniprot_matched.at[i, 'wt']
            can = str(uniprot_matched.at[i, 'uniprotSequence'])[int(uniprot_matched.at[i, 'pos']) - 1]
            ## Information about whether the mutation is found on the canonical or isoform sequence.

            if wt == can:
                uniprot_matched.at[i, 'wt_sequence_match'] = 'm'
            elif wt != can:
                isoList = isoform_fasta[
                    isoform_fasta['uniprotID'] == uniprot_matched.at[i, 'uniprotID']].isoformSequence.to_list()
                for k in isoList:
                    if len(k) >= int(uniprot_matched.at[i, 'pos']):
                        resInIso = k[int(int(uniprot_matched.at[i, 'pos']) - 1)]
                        if wt == resInIso:
                            whichIsoform = isoform_fasta[isoform_fasta.isoformSequence == k].whichIsoform.to_list()[0]
                            uniprot_matched.at[i, 'wt_sequence_match'] = 'i'
                            uniprot_matched.at[i, 'whichIsoform'] = whichIsoform
                            break
        elif len(uniprot_matched.at[i, 'uniprotSequence']) < int(uniprot_matched.at[i, 'pos']):
            isoList = isoform_fasta[
                isoform_fasta['uniprotID'] == uniprot_matched.at[i, 'uniprotID']].isoformSequence.to_list()
            for k in isoList:
                if len(k) >= int(uniprot_matched.at[i, 'pos']):
                    resInIso = k[int(int(uniprot_matched.at[i, 'pos']) - 1)]
                    wt = uniprot_matched.at[i, 'wt']
                    if wt == resInIso:
                        whichIsoform = isoform_fasta[isoform_fasta.isoformSequence == k].whichIsoform.to_list()[0]
                        uniprot_matched.at[i, 'wt_sequence_match'] = 'i'
                        uniprot_matched.at[i, 'whichIsoform'] = whichIsoform
                        break
        uniprotID = uniprot_matched.at[i, 'uniprotID']
        datapoint = uniprot_matched.at[i, 'datapoint']

        for k in annotation_list:
            txt = k + 'Binary'

            if (str(uniprot_matched.at[i, txt]) == '0') or (str(uniprot_matched.at[i, txt]) == '0.0'):
                uniprot_matched.at[i, txt] = '1'
            elif (str(uniprot_matched.at[i, txt]).lower() == 'nan') | (str(uniprot_matched.at[i, txt]) == np.NaN) :
                uniprot_matched.at[i, txt] = '0'
            elif (str(uniprot_matched.at[i, txt]) == '1') or (str(uniprot_matched.at[i, txt]) == '1.0'):
                uniprot_matched.at[i, txt] = '2'
        ## Search in all models.
        models_for_protein = [val for key, val in model_count.items() if
                              uniprotID in key.split(';')]  # We have this many models for the protein.
        which_model_mutation = which_model(
            int(uniprot_matched.at[i, 'pos']))  # List of models in which the mutation can be found.
        models_for_all_annotations = {}
        for annot in annotation_list:
            if len(uniprot_matched.at[i, annot]) != 0 and type(uniprot_matched.at[i, annot]) != list:
                uniprot_matched.at[i, annot] = list(
                    map(str.strip, uniprot_matched.at[i, annot].strip('][').replace('"', '').split(',')))
            models_for_annotations = {}  # Recording which position is found in which model file.
            for annot_position in uniprot_matched.at[i, annot]:
                if annot_position != 'nan' and annot_position != '':
                    models_for_that_position = which_model(int(annot_position))
                else:
                    models_for_that_position = {}
                for key, val in models_for_that_position.items():
                    if key not in models_for_annotations.keys():
                        models_for_annotations[key] = [val]
                    else:
                        models_for_annotations[key] += [val]
            models_for_all_annotations[annot] = models_for_annotations
        new_dict = {}
        for key, val in models_for_all_annotations.items():
            subdict = {k: v for k, v in val.items() if k in which_model_mutation}
            subdict = dict(sorted(subdict.items()))
            new_dict[key] = subdict
        new_dict = reduce_model_dict(new_dict)
        models_we_need = list(set(itertools.chain.from_iterable(
            [list(ov.keys()) for ok, ov in new_dict.items()])))  # Read models with these numbers
        info_per_model = {}  # her bir datapoint için baştan yazılıyor.
        dist_of_annots = {}
        all_domain_distances = []

        for mod in models_we_need:
            print('---------PRINTING FOR MODEL--------', mod)
            dist_of_annots[str(mod)] = {}
            info_per_model[mod] = {}
            info_per_model[mod]['datapoint'] = datapoint
            identifier = uniprot_matched.at[i, 'uniprotSequence']
            try:
                pdbSequence = pdb_info.loc[(pdb_info.uniprotID == uniprotID) & (
                        pdb_info.model_num == mod)].sequence.item()
            except:
                ValueError
                pdbSequence = 'nan'
            if pdbSequence != 'nan':  # The number in models we need might not be present for that protein. Preventng error.
                pdbSequence = pdb_info.loc[(pdb_info.uniprotID == uniprotID) & (pdb_info.model_num == mod)].sequence.item()
                alignment_list = do_alignment(uniprot_matched.at[i, 'datapoint'], uniprot_matched.at[i, 'uniprotSequence'],
                                              pdbSequence, Path(path_to_output_files / 'alignment_files'))
                pdb_alignStatus = mutation_position_on_pdb(alignment_list, uniprot_matched.at[i, 'pos'])[0]
                info_per_model[mod]['pdb_alignStatus'] = pdb_alignStatus
                mutationPositionOnPDB = mutation_position_on_pdb(alignment_list, uniprot_matched.at[i, 'pos'])[1]
                info_per_model[mod]['mutationPositionOnPDB'] = mutationPositionOnPDB
                startGap = mutation_position_on_pdb(alignment_list, uniprot_matched.at[i, 'pos'])[2]
                info_per_model[mod]['startGap'] = startGap
                alignment_to_use = mutation_position_on_pdb(alignment_list, uniprot_matched.at[i, 'pos'])[3]
                for annot in annotation_list:
                    if new_dict[annot] == {}:
                        annotation_pos_on_pdb_ = []
                    else:
                        try:
                            annotation_pos_on_pdb_ = annotation_pos_on_pdb(new_dict[annot][mod], startGap, alignment_to_use,
                                                                           identifier)
                        except:
                            KeyError
                    info_per_model[mod][annot] = annotation_pos_on_pdb_

                pdb_path = Path(f'{alphafold_path}/AF-{uniprotID}-F{mod}-{file_str}.pdb.gz')

                if get_alignments_3D(uniprotID, mod, pdb_path, pdbSequence, 'nan', 'nan', 'nan', mode, Path(path_to_output_files / '3D_alignment'),
                                     'gzip') != None:

                    alignments, coords, resnums_for_sasa = get_alignments_3D(uniprotID, mod, pdb_path, pdbSequence, 'nan',
                                                                            'nan', 'nan', mode, Path(path_to_output_files / '3D_alignment'),
                                                                            'gzip')
                    alignments = alignments[0]

                    calculate_freesasa(uniprotID, mod, existing_free_sasa, alphafold_path, path_to_output_files)
                    if (mutationPositionOnPDB != 'nan'):
                        if (int(mutationPositionOnPDB) <= 1400):
                            try:
                                coordMut = get_coords(mutationPositionOnPDB, alignments, coords, resnums_for_sasa, mode)[0]
                            except:
                                ValueError
                                coordMut = 'nan'
                        else:
                            coordMut = np.NaN

                        sasa_pos = get_coords(mutationPositionOnPDB, alignments, coords, resnums_for_sasa, mode)[2]
                        sasa_val = sasa('alphafold', 'nan', uniprotID, sasa_pos, uniprot_matched.at[i, 'wt'], mode,
                                        path_to_output_files, file_type='gzip')

                        if sasa_val != None:
                            uniprot_matched.at[i, 'sasa'] = sasa_val
                    else:
                        coordMut = 'nan'
                        sasa_val = 'nan'
                        uniprot_matched.at[i, 'sasa'] = sasa_val

                    domainPositionOnPDB_list = list(
                        range(int(uniprot_matched.at[i, 'domStart']), int(uniprot_matched.at[i, 'domEnd'])))
                    domain_distances = []
                    if len(domainPositionOnPDB_list) != 0:
                        for domain_ in domainPositionOnPDB_list:
                            coordDomain = get_coords(domain_, alignments, coords, resnums_for_sasa, mode)[0]
                            distance_dom = float(find_distance(coordMut,
                                                               coordDomain))  # bu bir anotasyonun bir modeldeki bir tane pozisyonu için.
                            domain_distances.append(distance_dom)
                        minimum_domain = min(domain_distances)  # minimum for one model.
                    else:
                        minimum_domain = np.NaN
                    all_domain_distances.append(minimum_domain)
                    list_dist_of_annots = []
                    for key, val in info_per_model.items():
                        modNum = key
                        min_annots = {}  # Write from scratch for each annotation.

                        if modNum == mod:
                            for label, annotPos in val.items():  # For each annotation type, calculate all distances of the annot positions.
                                if label in annotation_list:
                                    all_annot_distance_per_model = []  # All distances of an annoation in hat model
                                    for annot_position in annotPos:
                                        if (annot_position != 'nan'):
                                            if (int(annot_position) <= 1400):
                                                coordAnnot = \
                                                    get_coords(annot_position, alignments, coords, resnums_for_sasa, mode)[
                                                        0]
                                                distance = float(find_distance(coordMut,
                                                                               coordAnnot))  # bu bir anotasyonun bir modeldeki bir tane pozisyonu için.
                                                all_annot_distance_per_model.append(distance)
                                    if all_annot_distance_per_model != []:
                                        all_annot_distance_per_model = [float(i) for i in all_annot_distance_per_model]
                                        try:
                                            minimum_position = float(min(all_annot_distance_per_model))
                                        except:
                                            ValueError
                                            minimum_position = 'nan'
                                        min_annots[label] = float(
                                            minimum_position)  # Minimum of the annotation in this model.
                        if min_annots != {}:
                            list_dist_of_annots.append(min_annots)
                    dist_of_annots[str(
                        mod)] = list_dist_of_annots  # Getting minimum of all possible models
                #                uniprot_matched.at[i, annotation_type] = minimum_position
                else:
                    print('Model File Not Found')

                    uniprot_matched.at[i, 'sasa'] = np.NaN


        if len(all_domain_distances) != 0:
            uniprot_matched.at[i, 'domaindistance3D'] = min(all_domain_distances)
        else:
            uniprot_matched.at[i, 'domaindistance3D'] = np.NaN
        dist_of_annots_min_of_all = {}
        flat = [item for sublist in list(dist_of_annots.values()) for item in sublist]
        for f in flat:
            for key, val in f.items():
                if key not in dist_of_annots_min_of_all.keys():
                    dist_of_annots_min_of_all[key] = val
                elif (key in dist_of_annots_min_of_all.keys()) & (float(dist_of_annots_min_of_all[key]) > float(val)):
                    dist_of_annots_min_of_all[key] = val
        key_list = []
        for key, val in dist_of_annots_min_of_all.items():
            uniprot_matched.at[i, key] = val
            key_list.append(key)
        remaining = list(set(annotation_list) - set(key_list))

        for rem in remaining:
            uniprot_matched.at[i, rem] = ''
        uniprot_matched.at[i, 'distances'] = [dist_of_annots]

        if (uniprot_matched.at[i, 'sasa'] != None) & (uniprot_matched.at[i, 'sasa'] != np.NaN) & (
                str(uniprot_matched.at[i, 'sasa']) != 'nan'):
            if '*' in uniprot_matched.at[i, 'sasa']:
                uniprot_matched.at[i, 'sasa'] = uniprot_matched.at[i, 'sasa'].split('*')[0]
        try:
            uniprot_matched.at[i, 'sasa'] = float(uniprot_matched.at[i, 'sasa'].strip())
        except:
            TypeError

        if float(uniprot_matched.at[i, 'sasa']) < 5:
            uniprot_matched.at[i, 'trsh4'] = 'core'
        elif float(uniprot_matched.at[i, 'sasa']) >= 5:
            uniprot_matched.at[i, 'trsh4'] = 'surface'
        elif str(uniprot_matched.at[i, 'sasa']) == 'nan':
            uniprot_matched.at[i, 'trsh4'] = 'nan'
        else:
            uniprot_matched.at[i, 'trsh4'] = 'nan'
        if (str(uniprot_matched.at[i, 'pos']) in uniprot_matched.at[i, 'interface_positions']) and uniprot_matched.at[
            i, 'trsh4'] == 'surface':
            uniprot_matched.at[i, 'threeState_trsh4_HQ'] = 'interface'
        elif (str(uniprot_matched.at[i, 'pos']) not in uniprot_matched.at[i, 'interface_positions']) and uniprot_matched.at[
            i, 'trsh4'] == 'surface':
            uniprot_matched.at[i, 'threeState_trsh4_HQ'] = 'surface'
        elif (str(uniprot_matched.at[i, 'pos']) not in uniprot_matched.at[i, 'interface_positions']) and uniprot_matched.at[
            i, 'trsh4'] == 'core':
            uniprot_matched.at[i, 'threeState_trsh4_HQ'] = 'core'
        elif (str(uniprot_matched.at[i, 'pos']) in uniprot_matched.at[i, 'interface_positions']) and uniprot_matched.at[
            i, 'trsh4'] == 'core':
            uniprot_matched.at[i, 'threeState_trsh4_HQ'] = 'conflict'
        elif uniprot_matched.at[i, 'trsh4'] == 'nan':
            uniprot_matched.at[i, 'threeState_trsh4_HQ'] = 'nan'
        if uniprot_matched.at[i, 'domain'] in significant_domains:
            uniprot_matched.at[i, 'domain_fisher'] = uniprot_matched.at[i, 'domain']
        else:
            uniprot_matched.at[i, 'domain_fisher'] = 'NULL'
        uniprot_matched = uniprot_matched.round(2)
        uniprot_matched = uniprot_matched.astype(str)

    uniprot_matched[ 'domain'] = uniprot_matched['domain'].replace({'-1': 'NULL'})
    uniprot_matched = uniprot_matched.drop_duplicates()
    uniprot_matched.rename(
        columns={'uniprotID': 'prot_uniprotAcc', 'wt': 'wt_residue', 'pos': 'position', 'mut': 'mut_residue',
                 'datapoint': 'meta_merged', 'datapoint_disease': 'meta-lab_merged', 'label': 'source_db',
                 'family': 'prot_family', 'domain': 'domains_all', 'domain_fisher': 'domains_sig',
                 'domaindistance3D': 'domains_3Ddist', 'threeState_trsh4_HQ': 'location_3state',
                 'disulfideBinary': 'disulfide_bin', 'intMetBinary': 'intMet_bin',
                 'intramembraneBinary': 'intramembrane_bin',
                 'naturalVariantBinary': 'naturalVariant_bin', 'dnaBindingBinary': 'dnaBinding_bin',
                 'activeSiteBinary': 'activeSite_bin',
                 'nucleotideBindingBinary': 'nucleotideBinding_bin', 'lipidationBinary': 'lipidation_bin',
                 'siteBinary': 'site_bin',
                 'transmembraneBinary': 'transmembrane_bin', 'crosslinkBinary': 'crosslink_bin',
                 'mutagenesisBinary': 'mutagenesis_bin',
                 'strandBinary': 'strand_bin', 'helixBinary': 'helix_bin', 'turnBinary': 'turn_bin',
                 'metalBindingBinary': 'metalBinding_bin',
                 'repeatBinary': 'repeat_bin', 'topologicalDomainBinary': 'topologicalDomain_bin',
                 'caBindingBinary': 'caBinding_bin',
                 'bindingSiteBinary': 'bindingSite_bin', 'regionBinary': 'region_bin',
                 'signalPeptideBinary': 'signalPeptide_bin',
                 'modifiedResidueBinary': 'modifiedResidue_bin', 'zincFingerBinary': 'zincFinger_bin',
                 'motifBinary': 'motif_bin',
                 'coiledCoilBinary': 'coiledCoil_bin', 'peptideBinary': 'peptide_bin',
                 'transitPeptideBinary': 'transitPeptide_bin',
                 'glycosylationBinary': 'glycosylation_bin', 'propeptideBinary': 'propeptide_bin',
                 'disulfide': 'disulfide_dist', 'intMet': 'intMet_dist',
                 'intramembrane': 'intramembrane_dist', 'naturalVariant': 'naturalVariant_dist',
                 'dnaBinding': 'dnaBinding_dist', 'activeSite': 'activeSite_dist',
                 'nucleotideBinding': 'nucleotideBinding_dist', 'lipidation': 'lipidation_dist', 'site': 'site_dist',
                 'transmembrane': 'transmembrane_dist', 'crosslink': 'crosslink_dist',
                 'mutagenesis': 'mutagenesis_dist', 'strand': 'strand_dist', 'helix': 'helix_dist', 'turn': 'turn_dist',
                 'metalBinding': 'metalBinding_dist', 'repeat': 'repeat_dist',
                 'topologicalDomain': 'topologicalDomain_dist', 'caBinding': 'caBinding_dist',
                 'bindingSite': 'bindingSite_dist', 'region': 'region_dist',
                 'signalPeptide': 'signalPeptide_dist', 'modifiedResidue': 'modifiedResidue_dist',
                 'zincFinger': 'zincFinger_dist', 'motif': 'motif_dist', 'coiledCoil': 'coiledCoil_dist',
                 'peptide': 'peptide_dist', 'transitPeptide': 'transitPeptide_dist',
                 'glycosylation': 'glycosylation_dist', 'propeptide': 'propeptide_dist'}, inplace=True)

    uniprot_matched = uniprot_matched[
        ['prot_uniprotAcc', 'wt_residue', 'mut_residue', 'position', 'meta_merged', 'composition', 'polarity', 'volume',
         'granthamScore', 'domains_all',
         'domains_sig', 'domains_3Ddist', 'sasa', 'location_3state', 'disulfide_bin', 'intMet_bin',
         'intramembrane_bin', 'naturalVariant_bin', 'dnaBinding_bin',
         'activeSite_bin', 'nucleotideBinding_bin', 'lipidation_bin', 'site_bin',
         'transmembrane_bin', 'crosslink_bin', 'mutagenesis_bin', 'strand_bin',
         'helix_bin', 'turn_bin', 'metalBinding_bin', 'repeat_bin',
         'caBinding_bin', 'topologicalDomain_bin', 'bindingSite_bin',
         'region_bin', 'signalPeptide_bin', 'modifiedResidue_bin',
         'zincFinger_bin', 'motif_bin', 'coiledCoil_bin', 'peptide_bin',
         'transitPeptide_bin', 'glycosylation_bin', 'propeptide_bin', 'disulfide_dist', 'intMet_dist',
         'intramembrane_dist',
         'naturalVariant_dist', 'dnaBinding_dist', 'activeSite_dist',
         'nucleotideBinding_dist', 'lipidation_dist', 'site_dist',
         'transmembrane_dist', 'crosslink_dist', 'mutagenesis_dist',
         'strand_dist', 'helix_dist', 'turn_dist', 'metalBinding_dist',
         'repeat_dist', 'caBinding_dist', 'topologicalDomain_dist',
         'bindingSite_dist', 'region_dist', 'signalPeptide_dist',
         'modifiedResidue_dist', 'zincFinger_dist', 'motif_dist',
         'coiledCoil_dist', 'peptide_dist', 'transitPeptide_dist',
         'glycosylation_dist', 'propeptide_dist']]
    uniprot_matched = uniprot_matched.reset_index()
    uniprot_matched = uniprot_matched.drop(columns = {'index'})
    # Imputation
    if (impute == 'True') or (impute == 'true'):
        filler = [20.71, 46.67, 28.13,15.5, 35.94, 21.84, 25.15, 45.15, 29.81, 29.91, 34.67, 24.72, 10.66,11.55, 13.02,
                  21.54,27.42, 38.39, 30.44, 20.9, 25.82, 46.12, 32.1, 35.96, 35.86, 37.88, 19.09, 35.2, 26.95, 37.48]
        col_index = 0

        for col_ in uniprot_matched.columns[-30:]:
            uniprot_matched[col_] = uniprot_matched[col_].fillna(filler[col_index])
            uniprot_matched[col_] = uniprot_matched[col_].replace({'nan': filler[col_index]})
            uniprot_matched[col_] = uniprot_matched[col_].replace({'': filler[col_index]})
            """
            if uniprot_matched[col_].values == '':
                uniprot_matched[col_] = filler[col_index]
            """
            col_index += 1

        uniprot_matched['domains_3Ddist'] = uniprot_matched['domains_3Ddist'].fillna(29.78)
        uniprot_matched['sasa'] = uniprot_matched['sasa'].fillna(35.6)
        uniprot_matched['location_3state'] = uniprot_matched['location_3state'].fillna('unknown')
    elif (impute == 'False') or (impute == 'false'):
        pass
    uniprot_matched = uniprot_matched.replace({'nan': np.NaN})
    uniprot_matched = uniprot_matched.replace({'['']': np.NaN})
    uniprot_matched.to_csv(path_to_output_files / 'featurevector_alphafold.txt', index=False, sep='\t')
    if len(uniprot_matched) == 0:
        print(
            'No feature vector could be produced for input data. Please check the presence of a structure for the input proteins.')

    print('Feature vector successfully created...')
    end = timer()
    hours, rem = divmod(end - start, 3600)
    minutes, seconds = divmod(rem, 60)
    print("Time passed: {:0>2}:{:0>2}:{:05.2f}".format(int(hours), int(minutes), seconds))
    sys.stdout.close()
    return uniprot_matched