# -*- coding: utf-8 -*-
#  Copyright (c) 2016-2017, Zhijiang Yao, Jie Dong and Dongsheng Cao
#  All rights reserved.
#  This file is part of the PyBioMed.
#  The contents are covered by the terms of the BSD license
#  which is included in the file license.txt, found at the root
#  of the PyBioMed source tree.
"""
##########################################################################################

This module is used for computing the Autocorrelation descriptors based different

 properties of AADs.You can also input your properties of AADs, then it can help you

to compute Autocorrelation descriptors based on the property of AADs. Currently, You

can get 720 descriptors for a given protein sequence based on our provided physicochemical

properties of AADs. You can freely use and distribute it. If you hava  any problem,

you could contact with us timely!

References:

[1]: http://www.genome.ad.jp/dbget/aaindex.html

[2]:Feng, Z.P. and Zhang, C.T. (2000) Prediction of membrane protein types based on

the hydrophobic index of amino acids. J Protein Chem, 19, 269-275.

[3]:Horne, D.S. (1988) Prediction of protein helix content from an autocorrelation

analysis of sequence hydrophobicities. Biopolymers, 27, 451-477.

[4]:Sokal, R.R. and Thomson, B.A. (2006) Population structure inferred by local

spatial autocorrelation: an Usage from an Amerindian tribal population. Am J

Phys Anthropol, 129, 121-131.

Authors: Zhijiang Yao and Dongsheng Cao.

Date: 2016.06.04

Email: gadsby@163.com

##########################################################################################
"""

# Core Library modules
import math
import string

AALetter = [
    "A",
    "R",
    "N",
    "D",
    "C",
    "Q",
    "E",
    "G",
    "H",
    "I",
    "L",
    "K",
    "M",
    "F",
    "P",
    "S",
    "T",
    "W",
    "Y",
    "V",
]

_Hydrophobicity = {
    "A": 0.02,
    "R": -0.42,
    "N": -0.77,
    "D": -1.04,
    "C": 0.77,
    "Q": -1.10,
    "E": -1.14,
    "G": -0.80,
    "H": 0.26,
    "I": 1.81,
    "L": 1.14,
    "K": -0.41,
    "M": 1.00,
    "F": 1.35,
    "P": -0.09,
    "S": -0.97,
    "T": -0.77,
    "W": 1.71,
    "Y": 1.11,
    "V": 1.13,
}

_AvFlexibility = {
    "A": 0.357,
    "R": 0.529,
    "N": 0.463,
    "D": 0.511,
    "C": 0.346,
    "Q": 0.493,
    "E": 0.497,
    "G": 0.544,
    "H": 0.323,
    "I": 0.462,
    "L": 0.365,
    "K": 0.466,
    "M": 0.295,
    "F": 0.314,
    "P": 0.509,
    "S": 0.507,
    "T": 0.444,
    "W": 0.305,
    "Y": 0.420,
    "V": 0.386,
}

_Polarizability = {
    "A": 0.046,
    "R": 0.291,
    "N": 0.134,
    "D": 0.105,
    "C": 0.128,
    "Q": 0.180,
    "E": 0.151,
    "G": 0.000,
    "H": 0.230,
    "I": 0.186,
    "L": 0.186,
    "K": 0.219,
    "M": 0.221,
    "F": 0.290,
    "P": 0.131,
    "S": 0.062,
    "T": 0.108,
    "W": 0.409,
    "Y": 0.298,
    "V": 0.140,
}

_FreeEnergy = {
    "A": -0.368,
    "R": -1.03,
    "N": 0.0,
    "D": 2.06,
    "C": 4.53,
    "Q": 0.731,
    "E": 1.77,
    "G": -0.525,
    "H": 0.0,
    "I": 0.791,
    "L": 1.07,
    "K": 0.0,
    "M": 0.656,
    "F": 1.06,
    "P": -2.24,
    "S": -0.524,
    "T": 0.0,
    "W": 1.60,
    "Y": 4.91,
    "V": 0.401,
}

_ResidueASA = {
    "A": 115.0,
    "R": 225.0,
    "N": 160.0,
    "D": 150.0,
    "C": 135.0,
    "Q": 180.0,
    "E": 190.0,
    "G": 75.0,
    "H": 195.0,
    "I": 175.0,
    "L": 170.0,
    "K": 200.0,
    "M": 185.0,
    "F": 210.0,
    "P": 145.0,
    "S": 115.0,
    "T": 140.0,
    "W": 255.0,
    "Y": 230.0,
    "V": 155.0,
}

_ResidueVol = {
    "A": 52.6,
    "R": 109.1,
    "N": 75.7,
    "D": 68.4,
    "C": 68.3,
    "Q": 89.7,
    "E": 84.7,
    "G": 36.3,
    "H": 91.9,
    "I": 102.0,
    "L": 102.0,
    "K": 105.1,
    "M": 97.7,
    "F": 113.9,
    "P": 73.6,
    "S": 54.9,
    "T": 71.2,
    "W": 135.4,
    "Y": 116.2,
    "V": 85.1,
}

_Steric = {
    "A": 0.52,
    "R": 0.68,
    "N": 0.76,
    "D": 0.76,
    "C": 0.62,
    "Q": 0.68,
    "E": 0.68,
    "G": 0.00,
    "H": 0.70,
    "I": 1.02,
    "L": 0.98,
    "K": 0.68,
    "M": 0.78,
    "F": 0.70,
    "P": 0.36,
    "S": 0.53,
    "T": 0.50,
    "W": 0.70,
    "Y": 0.70,
    "V": 0.76,
}

_Mutability = {
    "A": 100.0,
    "R": 65.0,
    "N": 134.0,
    "D": 106.0,
    "C": 20.0,
    "Q": 93.0,
    "E": 102.0,
    "G": 49.0,
    "H": 66.0,
    "I": 96.0,
    "L": 40.0,
    "K": -56.0,
    "M": 94.0,
    "F": 41.0,
    "P": 56.0,
    "S": 120.0,
    "T": 97.0,
    "W": 18.0,
    "Y": 41.0,
    "V": 74.0,
}


###You can continuely add other properties of AADs to compute the descriptors of protein sequence.


_AAProperty = (
    _Hydrophobicity,
    _AvFlexibility,
    _Polarizability,
    _FreeEnergy,
    _ResidueASA,
    _ResidueVol,
    _Steric,
    _Mutability,
)

_AAPropertyName = (
    "_Hydrophobicity",
    "_AvFlexibility",
    "_Polarizability",
    "_FreeEnergy",
    "_ResidueASA",
    "_ResidueVol",
    "_Steric",
    "_Mutability",
)


##################################################################################################
def _mean(listvalue):
    """
    The mean value of the list data.
    """
    return sum(listvalue) / len(listvalue)


##################################################################################################
def _std(listvalue, ddof=1):
    """
    The standard deviation of the list data.
    """
    mean = _mean(listvalue)
    temp = [math.pow(i - mean, 2) for i in listvalue]
    res = math.sqrt(sum(temp) / (len(listvalue) - ddof))
    return res


##################################################################################################


def NormalizeEachAAP(AAP):
    """
    ####################################################################################
    All of the amino acid indices are centralized and

    standardized before the calculation.

    Usage:

    result=NormalizeEachAAP(AAP)

    Input: AAP is a dict form containing the properties of 20 amino acids.

    Output: result is the a dict form containing the normalized properties

    of 20 amino acids.
    ####################################################################################
    """
    if len(AAP.values()) != 20:
        print("You can not input the correct number of properities of Amino acids!")
    else:
        Result = {}
        for i, j in AAP.items():
            Result[i] = (j - _mean(AAP.values())) / _std(AAP.values(), ddof=0)

    return Result


def CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, AAP, AAPName):
    """
    ####################################################################################
    you can use the function to compute MoreauBrotoAuto

    descriptors for different properties based on AADs.

    Usage:

    result=CalculateEachNormalizedMoreauBrotoAuto(protein,AAP,AAPName)

    Input: protein is a pure protein sequence.

    AAP is a dict form containing the properties of 20 amino acids (e.g., _AvFlexibility).

    AAPName is a string used for indicating the property (e.g., '_AvFlexibility').

    Output: result is a dict form containing 30 Normalized Moreau-Broto autocorrelation

    descriptors based on the given property.
    ####################################################################################
    """

    AAPdic = NormalizeEachAAP(AAP)

    Result = {}
    for i in range(1, 31):
        temp = 0
        for j in range(len(ProteinSequence) - i):
            temp = temp + AAPdic[ProteinSequence[j]] * AAPdic[ProteinSequence[j + 1]]
        if len(ProteinSequence) - i == 0:
            Result["MoreauBrotoAuto" + AAPName + str(i)] = round(
                temp / (len(ProteinSequence)), 3
            )
        else:
            Result["MoreauBrotoAuto" + AAPName + str(i)] = round(
                temp / (len(ProteinSequence) - i), 3
            )

    return Result


def CalculateEachMoranAuto(ProteinSequence, AAP, AAPName):
    """
    ####################################################################################
    you can use the function to compute MoranAuto

    descriptors for different properties based on AADs.

    Usage:

    result=CalculateEachMoranAuto(protein,AAP,AAPName)

    Input: protein is a pure protein sequence.

    AAP is a dict form containing the properties of 20 amino acids (e.g., _AvFlexibility).

    AAPName is a string used for indicating the property (e.g., '_AvFlexibility').

    Output: result is a dict form containing 30 Moran autocorrelation

    descriptors based on the given property.
    ####################################################################################
    """

    AAPdic = NormalizeEachAAP(AAP)

    cds = 0
    for i in AALetter:
        cds = cds + (ProteinSequence.count(i)) * (AAPdic[i])
    Pmean = cds / len(ProteinSequence)

    cc = []
    for i in ProteinSequence:
        cc.append(AAPdic[i])

    K = (_std(cc, ddof=0)) ** 2

    Result = {}
    for i in range(1, 31):
        temp = 0
        for j in range(len(ProteinSequence) - i):
            temp = temp + (AAPdic[ProteinSequence[j]] - Pmean) * (
                AAPdic[ProteinSequence[j + i]] - Pmean
            )
        if len(ProteinSequence) - i == 0:
            Result["MoranAuto" + AAPName + str(i)] = round(
                temp / (len(ProteinSequence)) / K, 3
            )
        else:
            Result["MoranAuto" + AAPName + str(i)] = round(
                temp / (len(ProteinSequence) - i) / K, 3
            )

    return Result


def CalculateEachGearyAuto(ProteinSequence, AAP, AAPName):
    """
    ####################################################################################
    you can use the function to compute GearyAuto

    descriptors for different properties based on AADs.

    Usage:

    result=CalculateEachGearyAuto(protein,AAP,AAPName)

    Input: protein is a pure protein sequence.

    AAP is a dict form containing the properties of 20 amino acids (e.g., _AvFlexibility).

    AAPName is a string used for indicating the property (e.g., '_AvFlexibility').

    Output: result is a dict form containing 30 Geary autocorrelation

    descriptors based on the given property.
    ####################################################################################
    """

    AAPdic = NormalizeEachAAP(AAP)

    cc = []
    for i in ProteinSequence:
        cc.append(AAPdic[i])

    K = ((_std(cc)) ** 2) * len(ProteinSequence) / (len(ProteinSequence) - 1)
    Result = {}
    for i in range(1, 31):
        temp = 0
        for j in range(len(ProteinSequence) - i):
            temp = (
                temp
                + (AAPdic[ProteinSequence[j]] - AAPdic[ProteinSequence[j + i]]) ** 2
            )
        if len(ProteinSequence) - i == 0:
            Result["GearyAuto" + AAPName + str(i)] = round(
                temp / (2 * (len(ProteinSequence))) / K, 3
            )
        else:
            Result["GearyAuto" + AAPName + str(i)] = round(
                temp / (2 * (len(ProteinSequence) - i)) / K, 3
            )
    return Result


##################################################################################################


def CalculateNormalizedMoreauBrotoAuto(ProteinSequence, AAProperty, AAPropertyName):
    """
    ####################################################################################
    A method used for computing MoreauBrotoAuto for all properties.

    Usage:

    result=CalculateNormalizedMoreauBrotoAuto(protein,AAP,AAPName)

    Input: protein is a pure protein sequence.

    AAProperty is a list or tuple form containing the properties of 20 amino acids (e.g., _AAProperty).

    AAPName is a list or tuple form used for indicating the property (e.g., '_AAPropertyName').

    Output: result is a dict form containing 30*p Normalized Moreau-Broto autocorrelation

    descriptors based on the given properties.
    ####################################################################################

    """
    Result = {}
    for i in range(len(AAProperty)):
        Result[AAPropertyName[i]] = CalculateEachNormalizedMoreauBrotoAuto(
            ProteinSequence, AAProperty[i], AAPropertyName[i]
        )

    return Result


def CalculateMoranAuto(ProteinSequence, AAProperty, AAPropertyName):
    """
    ####################################################################################
    A method used for computing MoranAuto for all properties

    Usage:

    result=CalculateMoranAuto(protein,AAP,AAPName)

    Input: protein is a pure protein sequence.

    AAProperty is a list or tuple form containing the properties of 20 amino acids (e.g., _AAProperty).

    AAPName is a list or tuple form used for indicating the property (e.g., '_AAPropertyName').

    Output: result is a dict form containing 30*p Moran autocorrelation

    descriptors based on the given properties.
    ####################################################################################
    """
    Result = {}
    for i in range(len(AAProperty)):
        Result[AAPropertyName[i]] = CalculateEachMoranAuto(
            ProteinSequence, AAProperty[i], AAPropertyName[i]
        )

    return Result


def CalculateGearyAuto(ProteinSequence, AAProperty, AAPropertyName):
    """
    ####################################################################################
    A method used for computing GearyAuto for all properties

    Usage:

    result=CalculateGearyAuto(protein,AAP,AAPName)

    Input: protein is a pure protein sequence.

    AAProperty is a list or tuple form containing the properties of 20 amino acids (e.g., _AAProperty).

    AAPName is a list or tuple form used for indicating the property (e.g., '_AAPropertyName').

    Output: result is a dict form containing 30*p Geary autocorrelation

    descriptors based on the given properties.
    ####################################################################################
    """
    Result = {}
    for i in range(len(AAProperty)):
        Result[AAPropertyName[i]] = CalculateEachGearyAuto(
            ProteinSequence, AAProperty[i], AAPropertyName[i]
        )

    return Result


########################NormalizedMoreauBorto##################################
def CalculateNormalizedMoreauBrotoAutoHydrophobicity(ProteinSequence):
    """
    ####################################################################################
    Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on

    hydrophobicity.

    Usage:

    result=CalculateNormalizedMoreauBrotoAutoHydrophobicity(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation

    descriptors based on Hydrophobicity.
    ####################################################################################
    """

    result = CalculateEachNormalizedMoreauBrotoAuto(
        ProteinSequence, _Hydrophobicity, "_Hydrophobicity"
    )
    return result


def CalculateNormalizedMoreauBrotoAutoAvFlexibility(ProteinSequence):
    """
    ####################################################################################
    Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on

    AvFlexibility.

    Usage:

    result=CalculateNormalizedMoreauBrotoAutoAvFlexibility(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation

    descriptors based on AvFlexibility.
    ####################################################################################
    """

    result = CalculateEachNormalizedMoreauBrotoAuto(
        ProteinSequence, _AvFlexibility, "_AvFlexibility"
    )
    return result


def CalculateNormalizedMoreauBrotoAutoPolarizability(ProteinSequence):
    """
    ####################################################################################
    Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on

    Polarizability.

    Usage:

    result=CalculateNormalizedMoreauBrotoAutoPolarizability(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation

    descriptors based on Polarizability.
    ####################################################################################
    """

    result = CalculateEachNormalizedMoreauBrotoAuto(
        ProteinSequence, _Polarizability, "_Polarizability"
    )
    return result


def CalculateNormalizedMoreauBrotoAutoFreeEnergy(ProteinSequence):
    """
    ####################################################################################
    Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on

    FreeEnergy.

    Usage:

    result=CalculateNormalizedMoreauBrotoAutoFreeEnergy(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation

    descriptors based on FreeEnergy.
    ####################################################################################
    """

    result = CalculateEachNormalizedMoreauBrotoAuto(
        ProteinSequence, _FreeEnergy, "_FreeEnergy"
    )
    return result


def CalculateNormalizedMoreauBrotoAutoResidueASA(ProteinSequence):
    """
    ####################################################################################
    Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on

    ResidueASA.

    Usage:

    result=CalculateNormalizedMoreauBrotoAutoResidueASA(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation

    descriptors based on ResidueASA.
    ####################################################################################
    """

    result = CalculateEachNormalizedMoreauBrotoAuto(
        ProteinSequence, _ResidueASA, "_ResidueASA"
    )
    return result


def CalculateNormalizedMoreauBrotoAutoResidueVol(ProteinSequence):
    """
    ####################################################################################
    Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on

    ResidueVol.

    Usage:

    result=CalculateNormalizedMoreauBrotoAutoResidueVol(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation

    descriptors based on ResidueVol.
    ####################################################################################
    """

    result = CalculateEachNormalizedMoreauBrotoAuto(
        ProteinSequence, _ResidueVol, "_ResidueVol"
    )
    return result


def CalculateNormalizedMoreauBrotoAutoSteric(ProteinSequence):
    """
    ####################################################################################
    Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on Steric.

    Usage:

    result=CalculateNormalizedMoreauBrotoAutoSteric(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation

    descriptors based on Steric.
    ####################################################################################
    """

    result = CalculateEachNormalizedMoreauBrotoAuto(ProteinSequence, _Steric, "_Steric")
    return result


def CalculateNormalizedMoreauBrotoAutoMutability(ProteinSequence):
    """
    ####################################################################################
    Calculte the NormalizedMoreauBorto Autocorrelation descriptors based on Mutability.

    Usage:

    result=CalculateNormalizedMoreauBrotoAutoMutability(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Normalized Moreau-Broto Autocorrelation

    descriptors based on Mutability.
    ####################################################################################
    """

    result = CalculateEachNormalizedMoreauBrotoAuto(
        ProteinSequence, _Mutability, "_Mutability"
    )
    return result


############################################################################

##############################MoranAuto######################################
def CalculateMoranAutoHydrophobicity(ProteinSequence):
    """
    ####################################################################################
    Calculte the MoranAuto Autocorrelation descriptors based on hydrophobicity.

    Usage:

    result=CalculateMoranAutoHydrophobicity(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Moran Autocorrelation

    descriptors based on hydrophobicity.
    ####################################################################################
    """

    result = CalculateEachMoranAuto(ProteinSequence, _Hydrophobicity, "_Hydrophobicity")
    return result


def CalculateMoranAutoAvFlexibility(ProteinSequence):
    """
    ####################################################################################
    Calculte the MoranAuto Autocorrelation descriptors based on

    AvFlexibility.

    Usage:

    result=CalculateMoranAutoAvFlexibility(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Moran Autocorrelation

    descriptors based on AvFlexibility.
    ####################################################################################
    """

    result = CalculateEachMoranAuto(ProteinSequence, _AvFlexibility, "_AvFlexibility")
    return result


def CalculateMoranAutoPolarizability(ProteinSequence):
    """
    ####################################################################################
    Calculte the MoranAuto Autocorrelation descriptors based on

    Polarizability.

    Usage:

    result=CalculateMoranAutoPolarizability(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Moran Autocorrelation

    descriptors based on Polarizability.
    ####################################################################################
    """

    result = CalculateEachMoranAuto(ProteinSequence, _Polarizability, "_Polarizability")
    return result


def CalculateMoranAutoFreeEnergy(ProteinSequence):
    """
    ####################################################################################
    Calculte the MoranAuto Autocorrelation descriptors based on

    FreeEnergy.

    Usage:

    result=CalculateMoranAutoFreeEnergy(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Moran Autocorrelation

    descriptors based on FreeEnergy.
    ####################################################################################
    """

    result = CalculateEachMoranAuto(ProteinSequence, _FreeEnergy, "_FreeEnergy")
    return result


def CalculateMoranAutoResidueASA(ProteinSequence):
    """
    ####################################################################################
    Calculte the MoranAuto Autocorrelation descriptors based on

    ResidueASA.

    Usage:

    result=CalculateMoranAutoResidueASA(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Moran Autocorrelation

    descriptors based on ResidueASA.
    ####################################################################################
    """

    result = CalculateEachMoranAuto(ProteinSequence, _ResidueASA, "_ResidueASA")
    return result


def CalculateMoranAutoResidueVol(ProteinSequence):
    """
    ####################################################################################
    Calculte the MoranAuto Autocorrelation descriptors based on

    ResidueVol.

    Usage:

    result=CalculateMoranAutoResidueVol(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Moran Autocorrelation

    descriptors based on ResidueVol.
    ####################################################################################
    """

    result = CalculateEachMoranAuto(ProteinSequence, _ResidueVol, "_ResidueVol")
    return result


def CalculateMoranAutoSteric(ProteinSequence):
    """
    ####################################################################################
    Calculte the MoranAuto Autocorrelation descriptors based on

    AutoSteric.

    Usage:

    result=CalculateMoranAutoSteric(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Moran Autocorrelation

    descriptors based on AutoSteric.
    ####################################################################################
    """

    result = CalculateEachMoranAuto(ProteinSequence, _Steric, "_Steric")
    return result


def CalculateMoranAutoMutability(ProteinSequence):
    """
    ####################################################################################
    Calculte the MoranAuto Autocorrelation descriptors based on

    Mutability.

    Usage:

    result=CalculateMoranAutoMutability(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Moran Autocorrelation

    descriptors based on Mutability.
    ####################################################################################
    """

    result = CalculateEachMoranAuto(ProteinSequence, _Mutability, "_Mutability")
    return result


############################################################################


################################GearyAuto#####################################
def CalculateGearyAutoHydrophobicity(ProteinSequence):
    """
    ####################################################################################
    Calculte the GearyAuto Autocorrelation descriptors based on

    hydrophobicity.

    Usage:

    result=CalculateGearyAutoHydrophobicity(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Geary Autocorrelation

    descriptors based on hydrophobicity.
    ####################################################################################
    """

    result = CalculateEachGearyAuto(ProteinSequence, _Hydrophobicity, "_Hydrophobicity")
    return result


def CalculateGearyAutoAvFlexibility(ProteinSequence):
    """
    ####################################################################################
    Calculte the GearyAuto Autocorrelation descriptors based on

    AvFlexibility.

    Usage:
    result=CalculateGearyAutoAvFlexibility(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Geary Autocorrelation

    descriptors based on AvFlexibility.
    ####################################################################################
    """

    result = CalculateEachGearyAuto(ProteinSequence, _AvFlexibility, "_AvFlexibility")
    return result


def CalculateGearyAutoPolarizability(ProteinSequence):
    """
    ####################################################################################
    Calculte the GearyAuto Autocorrelation descriptors based on

    Polarizability.

    Usage:

    result=CalculateGearyAutoPolarizability(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Geary Autocorrelation

    descriptors based on Polarizability.
    ####################################################################################
    """

    result = CalculateEachGearyAuto(ProteinSequence, _Polarizability, "_Polarizability")
    return result


def CalculateGearyAutoFreeEnergy(ProteinSequence):
    """
    ####################################################################################
    Calculte the GearyAuto Autocorrelation descriptors based on

    FreeEnergy.

    Usage:

    result=CalculateGearyAutoFreeEnergy(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Geary Autocorrelation

    descriptors based on FreeEnergy.
    ####################################################################################
    """

    result = CalculateEachGearyAuto(ProteinSequence, _FreeEnergy, "_FreeEnergy")
    return result


def CalculateGearyAutoResidueASA(ProteinSequence):
    """
    ####################################################################################
    Calculte the GearyAuto Autocorrelation descriptors based on

    ResidueASA.

    Usage:

    result=CalculateGearyAutoResidueASA(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Geary Autocorrelation

    descriptors based on ResidueASA.
    ####################################################################################
    """

    result = CalculateEachGearyAuto(ProteinSequence, _ResidueASA, "_ResidueASA")
    return result


def CalculateGearyAutoResidueVol(ProteinSequence):
    """
    ####################################################################################
    Calculte the GearyAuto Autocorrelation descriptors based on

    ResidueVol.

    Usage:

    result=CalculateGearyAutoResidueVol(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Geary Autocorrelation

    descriptors based on ResidueVol.
    ####################################################################################
    """

    result = CalculateEachGearyAuto(ProteinSequence, _ResidueVol, "_ResidueVol")
    return result


def CalculateGearyAutoSteric(ProteinSequence):
    """
    ####################################################################################
    Calculte the GearyAuto Autocorrelation descriptors based on

    Steric.

    Usage:

    result=CalculateGearyAutoSteric(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Geary Autocorrelation

    descriptors based on Steric.
    ####################################################################################
    """

    result = CalculateEachGearyAuto(ProteinSequence, _Steric, "_Steric")
    return result


def CalculateGearyAutoMutability(ProteinSequence):
    """
    ####################################################################################
    Calculte the GearyAuto Autocorrelation descriptors based on

    Mutability.

    Usage:

    result=CalculateGearyAutoMutability(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30 Geary Autocorrelation

    descriptors based on Mutability.
    ####################################################################################
    """

    result = CalculateEachGearyAuto(ProteinSequence, _Mutability, "_Mutability")
    return result


##################################################################################################


def CalculateNormalizedMoreauBrotoAutoTotal(ProteinSequence):
    """
    ####################################################################################
    A method used for computing normalized Moreau Broto autocorrelation descriptors based

    on 8 proterties of AADs.

    Usage:

    result=CalculateNormalizedMoreauBrotoAutoTotal(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30*8=240 normalized Moreau Broto

    autocorrelation descriptors based on the given properties(i.e., _AAPropert).
    ####################################################################################
    """
    result = {}
    result.update(CalculateNormalizedMoreauBrotoAutoHydrophobicity(ProteinSequence))
    result.update(CalculateNormalizedMoreauBrotoAutoAvFlexibility(ProteinSequence))
    result.update(CalculateNormalizedMoreauBrotoAutoPolarizability(ProteinSequence))
    result.update(CalculateNormalizedMoreauBrotoAutoFreeEnergy(ProteinSequence))
    result.update(CalculateNormalizedMoreauBrotoAutoResidueASA(ProteinSequence))
    result.update(CalculateNormalizedMoreauBrotoAutoResidueVol(ProteinSequence))
    result.update(CalculateNormalizedMoreauBrotoAutoSteric(ProteinSequence))
    result.update(CalculateNormalizedMoreauBrotoAutoMutability(ProteinSequence))
    return result


def CalculateMoranAutoTotal(ProteinSequence):
    """
    ####################################################################################
    A method used for computing Moran autocorrelation descriptors based on 8 properties of AADs.

    Usage:

    result=CalculateMoranAutoTotal(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30*8=240 Moran

    autocorrelation descriptors based on the given properties(i.e., _AAPropert).
    ####################################################################################
    """
    result = {}
    result.update(CalculateMoranAutoHydrophobicity(ProteinSequence))
    result.update(CalculateMoranAutoAvFlexibility(ProteinSequence))
    result.update(CalculateMoranAutoPolarizability(ProteinSequence))
    result.update(CalculateMoranAutoFreeEnergy(ProteinSequence))
    result.update(CalculateMoranAutoResidueASA(ProteinSequence))
    result.update(CalculateMoranAutoResidueVol(ProteinSequence))
    result.update(CalculateMoranAutoSteric(ProteinSequence))
    result.update(CalculateMoranAutoMutability(ProteinSequence))
    return result


def CalculateGearyAutoTotal(ProteinSequence):
    """
    ####################################################################################
    A method used for computing Geary autocorrelation descriptors based on 8 properties of AADs.

    Usage:

    result=CalculateGearyAutoTotal(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30*8=240 Geary

    autocorrelation descriptors based on the given properties(i.e., _AAPropert).
    ####################################################################################
    """
    result = {}
    result.update(CalculateGearyAutoHydrophobicity(ProteinSequence))
    result.update(CalculateGearyAutoAvFlexibility(ProteinSequence))
    result.update(CalculateGearyAutoPolarizability(ProteinSequence))
    result.update(CalculateGearyAutoFreeEnergy(ProteinSequence))
    result.update(CalculateGearyAutoResidueASA(ProteinSequence))
    result.update(CalculateGearyAutoResidueVol(ProteinSequence))
    result.update(CalculateGearyAutoSteric(ProteinSequence))
    result.update(CalculateGearyAutoMutability(ProteinSequence))
    return result


##################################################################################################
def CalculateAutoTotal(ProteinSequence):
    """
    ####################################################################################
    A method used for computing all autocorrelation descriptors based on 8 properties of AADs.

    Usage:

    result=CalculateGearyAutoTotal(protein)

    Input: protein is a pure protein sequence.

    Output: result is a dict form containing 30*8*3=720 normalized Moreau Broto, Moran, and Geary

    autocorrelation descriptors based on the given properties(i.e., _AAPropert).
    ####################################################################################
    """
    result = {}
    result.update(CalculateNormalizedMoreauBrotoAutoTotal(ProteinSequence))
    result.update(CalculateMoranAutoTotal(ProteinSequence))
    result.update(CalculateGearyAutoTotal(ProteinSequence))
    return result


##################################################################################################
if __name__ == "__main__":
    protein = "ADGCGVGEGTGQGPMCNCMCMKWVYADEDAADLESDSFADEDASLESDSFPWSNQRVFCSFADEDAS"
    temp1 = CalculateNormalizedMoreauBrotoAuto(
        protein, AAProperty=_AAProperty, AAPropertyName=_AAPropertyName
    )
    # print temp1
    temp2 = CalculateMoranAutoMutability(protein)
    print(temp2)
    print(len(CalculateAutoTotal(protein)))
