protpy 1.4.1__tar.gz → 1.4.2__tar.gz

{protpy-1.4.1/protpy.egg-info → protpy-1.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: protpy
-Version: 1.4.1
+Version: 1.4.2
 Summary: Python package for generating various biochemical, physicochemical and structural descriptors/features of protein sequences.
 Author-email: AJ McKenna <amckenna41@qub.ac.uk>
 Maintainer-email: AJ McKenna <amckenna41@qub.ac.uk>
@@ -32,9 +32,9 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aaindex>=1.2.0
-Requires-Dist: numpy>=2.4.4
-Requires-Dist: pandas>=3.0.2
+Requires-Dist: aaindex>=1.3.1
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: pandas>=2.0.2
 Requires-Dist: tqdm>=4.0.0
 Requires-Dist: varname>=0.15.1
 Provides-Extra: test

{protpy-1.4.1 → protpy-1.4.2}/docs/conf.py

@@ -13,7 +13,7 @@ sys.path.insert(0, os.path.abspath('..'))
 project = 'protpy'
 copyright = '2026, AJ McKenna'
 author = 'AJ McKenna'
-release = '1.4.1'
+release = '1.4.2'
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{protpy-1.4.1 → protpy-1.4.2}/protpy/__init__.py

@@ -12,7 +12,7 @@ amino_acids = ["A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P",
 
 #protPy package metadata
 __name__ = 'protpy'
-__version__ = "1.4.1"
+__version__ = "1.4.2"
 __description__ = "Python package for generating various biochemical, physicochemical and structural descriptors/features of protein sequences."
 __author__ = 'AJ McKenna: https://github.com/amckenna41'
 __authorEmail__ = 'amckenna41@qub.ac.uk'

{protpy-1.4.1 → protpy-1.4.2}/protpy/autocorrelation.py

@@ -131,10 +131,10 @@ def moreaubroto_autocorrelation(sequence: str, lag: int = 30,
 
     #iterate through list of properties, calculating autocorrelation values for the sequence, append to results dict
     for key in aai_properties:
-        temp = 0
         for i in range(1, lag+1):
+            temp = 0  # reset per lag
             for j in range(len(sequence)-i):
-                temp = temp + aai_properties[key][sequence[j]] * aai_properties[key][sequence[j+1]]
+                temp = temp + aai_properties[key][sequence[j]] * aai_properties[key][sequence[j+i]]
             if (len(sequence) - i == 0):
                 moreaubroto_autocorrelation["MBAuto_" + key + "_" + str(i)] = round(
                     temp / (len(sequence)), 3)
@@ -362,7 +362,7 @@ def geary_autocorrelation(sequence: str, lag: int = 30,
 
 def _std(array: list[float], ddof: int = 1) -> float:
     """
-    Calculate the standard deviation of the array data, with associated means Delta Degrees 
+    Calculate the standard deviation of the array data, with associated means Delta Degrees
     of Freedom (ddof).
 
     Parameters
@@ -377,5 +377,5 @@ def _std(array: list[float], ddof: int = 1) -> float:
     :result: np.array
         input array after standard deviation transformation.
     """
-    return math.sqrt(sum([math.pow(i - sum(array) / len(array), 2) for i in array]) 
-        / (len(array) - ddof))
+    mean = sum(array) / len(array)
+    return math.sqrt(sum(math.pow(v - mean, 2) for v in array) / (len(array) - ddof))

{protpy-1.4.1 → protpy-1.4.2}/protpy/composition.py

@@ -205,9 +205,10 @@ def tripeptide_composition(sequence: str) -> pd.DataFrame:
     =======
     :tripeptide_composition_df: pd.DataFrame
         pandas DataFrame of tripeptide composition for protein sequence. Dataframe will
-        be of the shape 1 x 8000, where 8000 is the number of features calculated 
-        from the descriptor (20^3 for the 20 canonical amino acids) and 1 is the 
-        input sequence.
+        be of the shape 1 x 8000, where 8000 is the number of features calculated
+        from the descriptor (20^3 for the 20 canonical amino acids) and 1 is the
+        input sequence. Values are percentages (0–100), consistent with
+        dipeptide_composition.
     """
     #validate input protein sequence
     sequence = _validate_sequence(sequence)
@@ -221,9 +222,10 @@ def tripeptide_composition(sequence: str) -> pd.DataFrame:
             for k in amino_acids:
                 tripeptides.append(i + j + k)
 
-    #get frequency of each tripeptide in the sequence
+    #get fractional frequency of each tripeptide (percentage), consistent with dipeptide_composition
+    total_tripeptides = len(sequence) - 2
     for i in tripeptides:
-        tripeptide_composition[i] = len(re.findall(i, sequence))
+        tripeptide_composition[i] = round(sequence.count(i) / total_tripeptides * 100, 3) if total_tripeptides > 0 else 0.0
 
     #transform values and columns to DataFrame
     tripeptide_composition_df = pd.DataFrame([list(tripeptide_composition.values())], 
@@ -1185,30 +1187,23 @@ def pseudo_amino_acid_composition(sequence: str, lamda: int = 30, weight: float
                 raise ValueError(f"Accession number not found in aaindex1: {prop}.")
             property_values.append(aaindex1[prop].values)
 
-    right_part = 0.0
     psuedo_aac = {}
-    rightpart = []
-
-    #calculate correlation factor for protein sequence using propeties
-    for i in range(lamda):
-        right_part = right_part + sequence_order_correlation_factor(sequence, i+1, property_values)
 
     #calculate amino acid composition
     aa_comp = amino_acid_composition(sequence)
-    
-    #compute first 20 pseudo amino acid descriptor components based on property_values,
-    #append descriptor values to dict
-    temp = 1 + weight + right_part
-    for index, i in enumerate(amino_acids):
-        psuedo_aac["PAAC_" + str(index + 1)] = round(aa_comp[i].values[0] / temp, 3)
 
-    #calculate correlation factor for protein sequence using propeties
-    for i in range(lamda):
-        rightpart.append(sequence_order_correlation_factor(sequence, i + 1, property_values))
+    #compute correlation factors once; reuse for both the first-20 and last-lamda features
+    rightpart = [sequence_order_correlation_factor(sequence, i + 1, property_values)
+                 for i in range(lamda)]
 
-    #compute last 20+lambda pseudo amino acid descriptor components based on property_values,
-    #append descriptor values to dict
+    #shared normalization denominator: 1 + w * Σθ_k  (Chou 2001)
     temp = 1 + weight * sum(rightpart)
+
+    #compute first 20 pseudo amino acid descriptor components (weighted AAComp)
+    for index, i in enumerate(amino_acids):
+        psuedo_aac["PAAC_" + str(index + 1)] = round(aa_comp[i].values[0] / temp, 3)
+
+    #compute last lamda pseudo amino acid descriptor components (sequence-order correlations)
     for index in range(20, 20 + lamda):
         psuedo_aac["PAAC_" + str(index + 1)] = round(
             weight * rightpart[index - 20] / temp * 100, 3)
@@ -1293,25 +1288,21 @@ def normalize_property(properties: dict[str, float]) -> dict[str, float]:
     """
     Normalize physicochemical/structural property values using
     their mean and standard deviation.
-    
+
     Parameters
     ==========
     :properties: dict
-        dictionary of amino acid values for a physicochemical property. 
-        
+        dictionary of amino acid values for a physicochemical property.
+
     Returns
     =======
     :normalized_vals: dict
         dict of normalized property values.
     """
-    normalized_vals = {}
-
-    #iterate over all property values, calculate their mean and standard dev
-    for i, j in properties.items():
-        mean = sum(properties.values()) / len(properties.values())
-        normalized_vals[i] = (j - mean) / _std(properties.values(), mean, ddof=0)
-
-    return normalized_vals
+    vals = list(properties.values())
+    mean = sum(vals) / len(vals)
+    std = _std(vals, mean, ddof=0)
+    return {aa: (v - mean) / std for aa, v in properties.items()}
 
 def _std(prop: list[float], mean: float, ddof: int = 1) -> float:
     """
@@ -1339,7 +1330,7 @@ def _std(prop: list[float], mean: float, ddof: int = 1) -> float:
 ######################## Amphiphilic Pseudo Amino Acid Composition ########################
 
 def amphiphilic_pseudo_amino_acid_composition(sequence: str, lamda: int = 30, weight: float = 0.5,
-    properties: list[dict[str, float]] = [hydrophobicity_, hydrophilicity_]) -> pd.DataFrame:
+    properties: list[dict[str, float]] | None = None) -> pd.DataFrame:
     """
     Amphiphillic pseudo amino acid composition (APAAComp) has the same form as the amino
     acid composition, but contains much more information that is related to the 
@@ -1358,59 +1349,59 @@ def amphiphilic_pseudo_amino_acid_composition(sequence: str, lamda: int = 30, we
         rank of correlation. Number of calculable descriptors depends on lambda value.
     :weight: float
         weighting factor.
-    :properties: list (default=[hydrophobicity, hydrophilicity])
-        list of dicts of physicochemical/structural property values for amino acids.
+    :properties: list[dict] | None (default=None → [hydrophobicity_, hydrophilicity_])
+        list of property dicts mapping each amino acid to a float value.
+        When None the default hydrophobicity and hydrophilicity scales are used.
 
     Returns
-    =======    
+    =======
     :amp_pseudo_amino_acid_composition_df: pd.Dataframe
-        output dataframe of calculated amphiphilic pseudo amino acid composition 
-        descriptors for input sequence. Dataframe will be of the shape 1 x N, where 
-        N is the number of features calculated from the descriptor (20 + 2*lambda) 
-        and 1 is the input sequence. By default, the shape will be 1 x 80 
-        (using default lamda=30).
+        output dataframe of calculated amphiphilic pseudo amino acid composition
+        descriptors for input sequence. Dataframe will be of the shape 1 x N, where
+        N is 20 + n_props * lamda (n_props = number of properties supplied).
+        With the default two properties and lamda=30 the shape is 1 x 80.
     """
+    if properties is None:
+        properties = [hydrophobicity_, hydrophilicity_]
+
     #validate input protein sequence
     sequence = _validate_sequence(sequence)
 
     #set lamda to its default value of 30 if <0, or > sequence len or not an int
     if ((lamda < 0) or (lamda > len(sequence)) or not isinstance(lamda, int)):
-        lamda = 30  
+        lamda = 30
 
     #validate weight, set default weight of 0.5 if invalid value input
     if ((weight < 0) or not (isinstance(weight, (float, int)))):
         weight = 0.5
 
-    #cast properties to list 
-    if not (isinstance(properties, list)):
+    #cast properties to list
+    if not isinstance(properties, list):
         properties = [properties]
 
+    n_props = len(properties)
     amp_pseudo_amino_acid_composition = {}
 
-    #calculate correlation factor in protein sequence
-    rightpart = 0.0
+    #compute all per-lag correlation factors in a single pass:
+    #rightpart = [p0_lag1, p1_lag1, p0_lag2, p1_lag2, ..., p{n-1}_lag{lamda}]
+    rightpart: list[float] = []
     for i in range(lamda):
-        rightpart = rightpart + sum(
-            amphiphilic_sequence_order_correlation_factor(sequence, k=i + 1))
-    
+        rightpart.extend(
+            amphiphilic_sequence_order_correlation_factor(sequence, k=i + 1, properties=properties))
+
     #calculate amino acid composition
     aa_composition = amino_acid_composition(sequence)
 
-    #compute first 20 pseudo amino acid descriptor components based on properties
-    temp = 1 + weight * rightpart
-    for index, i in enumerate(amino_acids):
-        amp_pseudo_amino_acid_composition["APAAC_" + str(index + 1)] = round(aa_composition[i].values[0] / temp, 3)
+    #shared normalization denominator: 1 + w * Σ(all correlation factors)
+    temp = 1 + weight * sum(rightpart)
 
-    #calculate correlation factor in protein sequence
-    rightpart = []
-    for i in range(lamda):
-        temp = amphiphilic_sequence_order_correlation_factor(sequence, k=i + 1)
-        rightpart.append(temp[0])
-        rightpart.append(temp[1])
+    #compute first 20 pseudo amino acid descriptor components (weighted AAComp)
+    for index, i in enumerate(amino_acids):
+        amp_pseudo_amino_acid_composition["APAAC_" + str(index + 1)] = round(
+            aa_composition[i].values[0] / temp, 3)
 
-    #compute remaining (20 + 2 * lamda) amphiphillic composition values
-    temp = 1 + weight * sum(rightpart)
-    for index in range(20, 20 + 2 * lamda):
+    #compute remaining n_props * lamda amphiphilic composition values
+    for index in range(20, 20 + n_props * lamda):
         amp_pseudo_amino_acid_composition["APAAC_" + str(index + 1)] = round(
             weight * rightpart[index - 20] / temp * 100, 3)
 
@@ -1420,9 +1411,10 @@ def amphiphilic_pseudo_amino_acid_composition(sequence: str, lamda: int = 30, we
 
     return amp_pseudo_amino_acid_composition_df
 
-def amphiphilic_sequence_order_correlation_factor(sequence: str, k: int = 1) -> list[float]:
-    """ 
-    Calculate Amphipillic sequence order correlation factor for sequence
+def amphiphilic_sequence_order_correlation_factor(sequence: str, k: int = 1,
+    properties: list[dict[str, float]] | None = None) -> list[float]:
+    """
+    Calculate Amphiphilic sequence order correlation factor for sequence
     with gap=k.
 
     Parameters
@@ -1431,34 +1423,36 @@ def amphiphilic_sequence_order_correlation_factor(sequence: str, k: int = 1) ->
         protein sequence.
     :k: int (default=1)
         gap between amino acids in the sequence.
+    :properties: list[dict] | None (default=None → [hydrophobicity_, hydrophilicity_])
+        list of property dicts. Pre-normalized once per call.
 
     Returns
     =======
-    :correlation_factor: list
-        list of correlation factors for both hydrophobicity and hydrophillicty.
+    :correlation_factor: list[float]
+        one correlation factor per property.
     """
-    correlation_factor_hydrophobicity = []
-    correlation_factor_hydrophilicity = []
+    if properties is None:
+        properties = [hydrophobicity_, hydrophilicity_]
 
-    #iterate over sequence, calculating correlation factors using both properties
-    for i in range(len(sequence) - k):
-        aa1 = sequence[i]
-        aa2 = sequence[i + k]
-        corelation_function = amphiphilic_correllation_function(aa1, aa2)
-        correlation_factor_hydrophobicity.append(corelation_function[0])
-        correlation_factor_hydrophilicity.append(corelation_function[1])
+    #pre-normalize all properties once rather than inside every pair evaluation
+    normalized_props = [normalize_property(prop) for prop in properties]
+    n_props = len(properties)
+    accumulators: list[list[float]] = [[] for _ in range(n_props)]
 
-    #append hydrophobicity and hydrophilicity values to array
-    correlation_factor = []
-    correlation_factor.append(round(sum(correlation_factor_hydrophobicity) / (len(sequence) - k), 3))
-    correlation_factor.append(round(sum(correlation_factor_hydrophilicity) / (len(sequence) - k), 3))
+    #iterate over sequence pairs with the given gap k
+    for i in range(len(sequence) - k):
+        aa1, aa2 = sequence[i], sequence[i + k]
+        for p_idx, norm in enumerate(normalized_props):
+            accumulators[p_idx].append(round(norm[aa1] * norm[aa2], 3))
 
-    return correlation_factor
+    denom = len(sequence) - k
+    return [round(sum(acc) / denom, 3) for acc in accumulators]
 
-def amphiphilic_correllation_function(Ri: str = "S", Rj: str = "D") -> tuple[float, float]:
+def amphiphilic_correllation_function(Ri: str = "S", Rj: str = "D",
+    normalized_props: list[dict[str, float]] | None = None) -> list[float]:
     """
-    Calculate correlation value based on hydrophobicity and hydrophillicity
-    property values for input amino acids Ri and Rj in sequence.
+    Calculate correlation value based on physicochemical property values
+    for input amino acids Ri and Rj.
 
     Parameters
     ==========
@@ -1466,18 +1460,16 @@ def amphiphilic_correllation_function(Ri: str = "S", Rj: str = "D") -> tuple[flo
         1st amino acid.
     :Rj: str
         2nd amino acid.
+    :normalized_props: list[dict] | None
+        pre-normalized property dicts. Defaults to normalized hydrophobicity
+        and hydrophilicity when None.
 
     Returns
     =======
-    :theta1, theta2: float
-        correlation values for input property values.
+    :thetas: list[float]
+        one correlation value per property.
     """
-    #normalize properties
-    _hydrophobicity = normalize_property(hydrophobicity_)
-    _hydrophilicity = normalize_property(hydrophilicity_)
-
-    #calculate correlation using hydrophobicity & hydrophilicty properties
-    theta1 = round(_hydrophobicity[Ri] * _hydrophobicity[Rj], 3)
-    theta2 = round(_hydrophilicity[Ri] * _hydrophilicity[Rj], 3)
-
-    return theta1, theta2
+    if normalized_props is None:
+        normalized_props = [normalize_property(hydrophobicity_),
+                            normalize_property(hydrophilicity_)]
+    return [round(prop[Ri] * prop[Rj], 3) for prop in normalized_props]

{protpy-1.4.1 → protpy-1.4.2}/protpy/encode.py

@@ -285,6 +285,7 @@ def encode_dataset(
     output_file: str | None = "descriptors.csv",
     save_each_sequence: bool = True,
     strip_gaps: bool = False,
+    verbose: bool = True,
 ) -> pd.DataFrame:
     """
     Compute all available descriptors for every sequence in a dataset and
@@ -334,6 +335,11 @@ def encode_dataset(
         amino acid.  When ``False`` (default), a ``-`` in any sequence raises
         a ``ValueError``.
 
+    :verbose: bool (default=True)
+        When ``True``, print a status line for each sequence as it is encoded
+        (``"Encoding sequence N/total: id"``).  Set to ``False`` to suppress
+        all stdout output from this function.
+
     Returns
     =======
     :result: pd.DataFrame
@@ -400,7 +406,8 @@ def encode_dataset(
     total = len(seqs)
 
     for idx, (seq_id, seq) in enumerate(zip(ids, seqs), start=1):
-        print(f"Encoding sequence {idx}/{total}: {seq_id}")
+        if verbose:
+            print(f"Encoding sequence {idx}/{total}: {seq_id}")
         if strip_gaps:
             seq = seq.replace("-", "")
         elif "-" in seq:

{protpy-1.4.1 → protpy-1.4.2}/protpy/sequence_order.py

@@ -6,10 +6,10 @@ from __future__ import annotations
 
 import os
 import json
+import functools
 from difflib import get_close_matches
 import pandas as pd
 import math
-from json import JSONDecodeError
 import sys
 from . import composition
 
@@ -33,6 +33,19 @@ References
 #list of amino acids
 from ._constants import amino_acids, _validate_sequence
 
+@functools.lru_cache(maxsize=2)
+def _load_distance_matrix(name: str) -> dict:
+    """Load and cache a physicochemical distance matrix JSON by name."""
+    path = os.path.join(
+        os.path.dirname(os.path.abspath(sys.modules['protpy'].__file__)),
+        "data", f"{name}-physicochemical-distance-matrix.json"
+    )
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except (OSError, json.JSONDecodeError):
+        raise ValueError(f"Error parsing distance matrix file: {path}.")
+
 ############################# Sequence Order Coupling Number ##############################
 
 def sequence_order_coupling_number_(sequence: str, d: int = 1, distance_matrix: str = "schneider-wrede") -> float:
@@ -73,24 +86,17 @@ def sequence_order_coupling_number_(sequence: str, d: int = 1, distance_matrix:
         raise ValueError(f"Could not find a match for the input distance matrix {distance_matrix} in"
             f" list of available valid distance matrices:\n{['schneider-wrede', 'grantham']}.")
     
-    #get full path to selected distance matric
-    distance_matrix = os.path.join(os.path.dirname(os.path.abspath(sys.modules['protpy'].__file__)), "data", distance_matrix + "-physicochemical-distance-matrix.json")
-        
-    #open distance matrix json if present
-    try:
-        with open(distance_matrix, "r") as f:
-            distance_matrix = json.load(f)
-    except (OSError, json.JSONDecodeError):
-        raise JSONDecodeError(f'Error parsing distance matrix JSON file: {distance_matrix}.')
+    #load (or retrieve cached) distance matrix
+    distance_matrix_data = _load_distance_matrix(distance_matrix)
 
     tau = 0.0
 
     #iterate over length of sequence minus gap, incrementing the SOCN at each iteration using
-    #the values from the distance matrix with the current and next amino acid, round to 2 dp
+    #the values from the distance matrix with the current and next amino acid
     for aa in range(len(sequence) - d):
         current_aa = sequence[aa]
         next_aa = sequence[aa + d]
-        tau = tau + math.pow(distance_matrix[current_aa + next_aa], 2)
+        tau = tau + math.pow(distance_matrix_data[current_aa + next_aa], 2)
 
     return round(tau, 3)
 

{protpy-1.4.1 → protpy-1.4.2/protpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: protpy
-Version: 1.4.1
+Version: 1.4.2
 Summary: Python package for generating various biochemical, physicochemical and structural descriptors/features of protein sequences.
 Author-email: AJ McKenna <amckenna41@qub.ac.uk>
 Maintainer-email: AJ McKenna <amckenna41@qub.ac.uk>
@@ -32,9 +32,9 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: aaindex>=1.2.0
-Requires-Dist: numpy>=2.4.4
-Requires-Dist: pandas>=3.0.2
+Requires-Dist: aaindex>=1.3.1
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: pandas>=2.0.2
 Requires-Dist: tqdm>=4.0.0
 Requires-Dist: varname>=0.15.1
 Provides-Extra: test

{protpy-1.4.1 → protpy-1.4.2}/protpy.egg-info/requires.txt

@@ -1,6 +1,6 @@
-aaindex>=1.2.0
-numpy>=2.4.4
-pandas>=3.0.2
+aaindex>=1.3.1
+numpy>=2.0.0
+pandas>=2.0.2
 tqdm>=4.0.0
 varname>=0.15.1
 

{protpy-1.4.1 → protpy-1.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "protpy"
-version = "1.4.1"
+version = "1.4.2"
 description = "Python package for generating various biochemical, physicochemical and structural descriptors/features of protein sequences."
 readme = "README.md"
 license = { text = "MIT" }
@@ -50,9 +50,9 @@ classifiers = [
 ]
 requires-python = ">=3.9"
 dependencies = [
-    "aaindex>=1.2.0",
-    "numpy>=2.4.4",
-    "pandas>=3.0.2",
+    "aaindex>=1.3.1",
+    "numpy>=2.0.0",
+    "pandas>=2.0.2",
     "tqdm>=4.0.0",
     "varname>=0.15.1",
 ]

{protpy-1.4.1 → protpy-1.4.2}/tests/test_autocorrelation.py

@@ -148,7 +148,7 @@ class ProtpyAutocorrelationTests(unittest.TestCase):
             properties=["CIDH920105"], normalize=False)
         moreaubroto_nf_expected = pd.DataFrame(columns=["MBAuto_CIDH920105_1", "MBAuto_CIDH920105_2",
             "MBAuto_CIDH920105_3", "MBAuto_CIDH920105_4", "MBAuto_CIDH920105_5"])
-        moreaubroto_nf_expected.loc[0] = [-0.054, -0.107, -0.161, -0.215, -0.269]
+        moreaubroto_nf_expected.loc[0] = [-0.054, -0.074, -0.038, -0.018, -0.05]
         self.assertIsInstance(moreaubroto_nf_seq1, pd.DataFrame,
             'Expected output to be of type DataFrame, got {}.'.format(type(moreaubroto_nf_seq1)))
         self.assertEqual(moreaubroto_nf_seq1.shape, (1, lag),

{protpy-1.4.1 → protpy-1.4.2}/tests/test_composition.py

@@ -345,7 +345,7 @@ class ProtpyCompositionTests(unittest.TestCase):
         tripeptide_comp_seq1 = protpy.tripeptide_composition(self.protein_seq1)
         #testing first 10 columns 
         tripeptide_comp_seq1_expected_values = pd.DataFrame(columns=["AAA", "AAC", "AAD", "AAE", "AAF", "AAG", "AAH", "AAI", "AAK", "AAL"])
-        tripeptide_comp_seq1_expected_values.loc[0] = [1, 0, 0, 2, 0, 0, 0, 0, 0, 2]
+        tripeptide_comp_seq1_expected_values.loc[0] = [0.08, 0.0, 0.0, 0.16, 0.0, 0.0, 0.0, 0.0, 0.0, 0.16]
 
         self.assertIsInstance(tripeptide_comp_seq1, pd.DataFrame,
             'Expected output to be of type DataFrame, got {}.'.format(type(tripeptide_comp_seq1)))
@@ -365,13 +365,13 @@ class ProtpyCompositionTests(unittest.TestCase):
                 "Amino acid {} not found in list of amino acids:\n{}.".format(col[2], self.amino_acids))
         self.assertTrue(tripeptide_comp_seq1.any().isnull().sum()==0,
             'Expected output to contain no null values.')        
-        self.assertTrue(all(col == np.int64 for col in list(tripeptide_comp_seq1.dtypes)),
+        self.assertTrue(all(col == np.float64 for col in list(tripeptide_comp_seq1.dtypes)),
             "Expected output values to be of datatype np.float64, got {}.".format(list(tripeptide_comp_seq1.dtypes)))
 #2.)
         tripeptide_comp_seq2 = protpy.tripeptide_composition(self.protein_seq2)
         #testing first 10 columns 
         tripeptide_comp_seq2_expected_values = pd.DataFrame(columns=["AAA", "AAC", "AAD", "AAE", "AAF", "AAG", "AAH", "AAI", "AAK", "AAL"])
-        tripeptide_comp_seq2_expected_values.loc[0] = [0, 0, 1, 1, 0, 0, 0, 0, 0, 0]
+        tripeptide_comp_seq2_expected_values.loc[0] = [0.0, 0.0, 0.238, 0.238, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
 
         self.assertIsInstance(tripeptide_comp_seq2, pd.DataFrame,
             'Expected output to be of type DataFrame, got {}.'.format(type(tripeptide_comp_seq2)))
@@ -391,13 +391,13 @@ class ProtpyCompositionTests(unittest.TestCase):
                 "Amino acid {} not found in list of amino acids:\n{}.".format(col[2], self.amino_acids))
         self.assertTrue(tripeptide_comp_seq2.any().isnull().sum()==0,
             'Expected output to contain no null values.')        
-        self.assertTrue(all(col == np.int64 for col in list(tripeptide_comp_seq2.dtypes)),
+        self.assertTrue(all(col == np.float64 for col in list(tripeptide_comp_seq2.dtypes)),
             "Expected output values to be of datatype np.float64, got {}.".format(list(tripeptide_comp_seq2.dtypes)))
 #3.)
         tripeptide_comp_seq3 = protpy.tripeptide_composition(self.protein_seq3)
         #testing first 10 columns 
         tripeptide_comp_seq3_expected_values = pd.DataFrame(columns=["AAA", "AAC", "AAD", "AAE", "AAF", "AAG", "AAH", "AAI", "AAK", "AAL"])
-        tripeptide_comp_seq3_expected_values.loc[0] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        tripeptide_comp_seq3_expected_values.loc[0] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
 
         self.assertIsInstance(tripeptide_comp_seq3, pd.DataFrame,
             'Expected output to be of type DataFrame, got {}.'.format(type(tripeptide_comp_seq3)))
@@ -417,13 +417,13 @@ class ProtpyCompositionTests(unittest.TestCase):
                 "Amino acid {} not found in list of amino acids:\n{}.".format(col[2], self.amino_acids))
         self.assertTrue(tripeptide_comp_seq3.any().isnull().sum()==0,
             'Expected output to contain no null values.')        
-        self.assertTrue(all(col == np.int64 for col in list(tripeptide_comp_seq3.dtypes)),
+        self.assertTrue(all(col == np.float64 for col in list(tripeptide_comp_seq3.dtypes)),
             "Expected output values to be of datatype np.float64, got {}.".format(list(tripeptide_comp_seq3.dtypes)))
 #4.)
         tripeptide_comp_seq4 = protpy.tripeptide_composition(self.protein_seq4)
         #testing first 10 columns 
         tripeptide_comp_seq4_expected_values = pd.DataFrame(columns=["AAA", "AAC", "AAD", "AAE", "AAF", "AAG", "AAH", "AAI", "AAK", "AAL"])
-        tripeptide_comp_seq4_expected_values.loc[0] = [0, 0, 1, 1, 0, 0, 0, 1, 0, 1]
+        tripeptide_comp_seq4_expected_values.loc[0] = [0.0, 0.0, 0.24, 0.24, 0.0, 0.0, 0.0, 0.24, 0.0, 0.24]
 
         self.assertIsInstance(tripeptide_comp_seq4, pd.DataFrame,
             'Expected output to be of type DataFrame, got {}.'.format(type(tripeptide_comp_seq4)))
@@ -443,7 +443,7 @@ class ProtpyCompositionTests(unittest.TestCase):
                 "Amino acid {} not found in list of amino acids:\n{}.".format(col[2], self.amino_acids))
         self.assertTrue(tripeptide_comp_seq4.any().isnull().sum()==0,
             'Expected output to contain no null values.')        
-        self.assertTrue(all(col == np.int64 for col in list(tripeptide_comp_seq4.dtypes)),
+        self.assertTrue(all(col == np.float64 for col in list(tripeptide_comp_seq4.dtypes)),
             "Expected output values to be of datatype np.float64, got {}.".format(list(tripeptide_comp_seq4.dtypes)))
 #5.)
         invalid_seq5 = "ABCDEF"
@@ -469,7 +469,7 @@ class ProtpyCompositionTests(unittest.TestCase):
         pseudo_amino_acid_composition_seq1 = protpy.pseudo_amino_acid_composition(self.protein_seq1, weight=weight, lamda=lamda)
         #testing first 10 columns 
         pseudo_amino_acid_composition_seq1_expected_values = pd.DataFrame(columns=["PAAC_1", "PAAC_2", "PAAC_3", "PAAC_4", "PAAC_5", "PAAC_6", "PAAC_7", "PAAC_8", "PAAC_9", "PAAC_10"])
-        pseudo_amino_acid_composition_seq1_expected_values.loc[0] = [0.127, 0.059, 0.111, 0.064, 0.126, 0.12, 0.023, 0.118, 0.091, 0.15]
+        pseudo_amino_acid_composition_seq1_expected_values.loc[0] = [1.871, 0.869, 1.626, 0.936, 1.849, 1.76, 0.334, 1.737, 1.336, 2.205]
      
         self.assertIsInstance(pseudo_amino_acid_composition_seq1, pd.DataFrame, 
             'Expected output to be of type DataFrame, got {}.'.format(type(pseudo_amino_acid_composition_seq1)))
@@ -489,7 +489,7 @@ class ProtpyCompositionTests(unittest.TestCase):
         pseudo_amino_acid_composition_seq2 = protpy.pseudo_amino_acid_composition(self.protein_seq2, weight=weight, lamda=lamda)
         #testing first 10 columns 
         pseudo_amino_acid_composition_seq2_expected_values = pd.DataFrame(columns=["PAAC_1", "PAAC_2", "PAAC_3", "PAAC_4", "PAAC_5", "PAAC_6", "PAAC_7", "PAAC_8", "PAAC_9", "PAAC_10"])
-        pseudo_amino_acid_composition_seq2_expected_values.loc[0] = [0.137, 0.0, 0.088, 0.056, 0.052, 0.181, 0.02, 0.044, 0.117, 0.105]
+        pseudo_amino_acid_composition_seq2_expected_values.loc[0] = [2.069, 0.0, 1.338, 0.852, 0.791, 2.738, 0.304, 0.669, 1.764, 1.582]
 
         self.assertIsInstance(pseudo_amino_acid_composition_seq2, pd.DataFrame, 
             'Expected output to be of type DataFrame, got {}.'.format(type(pseudo_amino_acid_composition_seq2)))
@@ -509,7 +509,7 @@ class ProtpyCompositionTests(unittest.TestCase):
         pseudo_amino_acid_composition_seq3 = protpy.pseudo_amino_acid_composition(self.protein_seq3, weight=weight, lamda=lamda)
         #testing first 10 columns 
         pseudo_amino_acid_composition_seq3_expected_values = pd.DataFrame(columns=["PAAC_1", "PAAC_2", "PAAC_3", "PAAC_4", "PAAC_5", "PAAC_6", "PAAC_7", "PAAC_8", "PAAC_9", "PAAC_10"])
-        pseudo_amino_acid_composition_seq3_expected_values.loc[0] = [0.126, 0.095, 0.032, 0.095, 0.126, 0.063, 0.0, 0.095, 0.063, 0.441]
+        pseudo_amino_acid_composition_seq3_expected_values.loc[0] = [1.735, 1.301, 0.434, 1.301, 1.735, 0.868, 0.0, 1.301, 0.868, 6.072]
 
         self.assertIsInstance(pseudo_amino_acid_composition_seq3, pd.DataFrame, 
             'Expected output to be of type DataFrame, got {}.'.format(type(pseudo_amino_acid_composition_seq3)))
@@ -529,7 +529,7 @@ class ProtpyCompositionTests(unittest.TestCase):
         pseudo_amino_acid_composition_seq4 = protpy.pseudo_amino_acid_composition(self.protein_seq4, weight=weight, lamda=lamda)
         #testing first 10 columns 
         pseudo_amino_acid_composition_seq4_expected_values = pd.DataFrame(columns=["PAAC_1", "PAAC_2", "PAAC_3", "PAAC_4", "PAAC_5", "PAAC_6", "PAAC_7", "PAAC_8", "PAAC_9", "PAAC_10"])
-        pseudo_amino_acid_composition_seq4_expected_values.loc[0] = [0.15, 0.0, 0.097, 0.048, 0.053, 0.174, 0.016, 0.057, 0.125, 0.109]
+        pseudo_amino_acid_composition_seq4_expected_values.loc[0] = [2.264, 0.0, 1.468, 0.734, 0.795, 2.631, 0.245, 0.856, 1.897, 1.652]
 
         self.assertIsInstance(pseudo_amino_acid_composition_seq4, pd.DataFrame, 
             'Expected output to be of type DataFrame, got {}.'.format(type(pseudo_amino_acid_composition_seq4)))

{protpy-1.4.1 → protpy-1.4.2}/tests/test_protpy.py

@@ -22,8 +22,8 @@ class ProtpyTests(unittest.TestCase):
     """
     def test_protpy_metadata(self):
         """ Testing correct protpy version and metadata. """
-        self.assertEqual(protpy.__version__, "1.4.1",
-            "protpy version is not correct, expected version 1.4.1, got version {}".format(protpy.__version__))
+        self.assertEqual(protpy.__version__, "1.4.2",
+            "protpy version is not correct, expected version 1.4.2, got version {}".format(protpy.__version__))
         self.assertEqual(protpy.__name__, "protpy", 
             "protpy software name is not correct, expected protpy, got {}.".format(protpy.__name__))
         self.assertEqual(protpy.__author__, "AJ McKenna: https://github.com/amckenna41",