protpy 1.3.0__tar.gz → 1.4.0__tar.gz

{protpy-1.3.0/protpy.egg-info → protpy-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: protpy
-Version: 1.3.0
+Version: 1.4.0
 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>
@@ -54,6 +54,7 @@ Dynamic: license-file
 [![pytest](https://github.com/amckenna41/protpy/workflows/Building%20and%20Testing/badge.svg)](https://github.com/amckenna41/protpy/actions?query=workflowBuilding%20and%20Testing)
 [![Platforms](https://img.shields.io/badge/platforms-linux%2C%20macOS%2C%20Windows-green)](https://pypi.org/project/protpy/)
 [![PythonV](https://img.shields.io/pypi/pyversions/protpy?logo=2)](https://pypi.org/project/protpy/)
+[![Documentation Status](https://readthedocs.org/projects/protpy/badge/?version=latest)](https://protpy.readthedocs.io/en/latest/?badge=latest)
 [![codecov](https://codecov.io/gh/amckenna41/protPy/graph/badge.svg?token=H508M9J13W)](https://codecov.io/gh/amckenna41/protPy)
 [![License: MIT](https://img.shields.io/badge/License-MIT-red.svg)](https://opensource.org/licenses/MIT)
 [![Issues](https://img.shields.io/github/issues/amckenna41/protpy)](https://github.com/amckenna41/protpy/issues)

{protpy-1.3.0 → protpy-1.4.0}/README.md

@@ -6,6 +6,7 @@
 [![pytest](https://github.com/amckenna41/protpy/workflows/Building%20and%20Testing/badge.svg)](https://github.com/amckenna41/protpy/actions?query=workflowBuilding%20and%20Testing)
 [![Platforms](https://img.shields.io/badge/platforms-linux%2C%20macOS%2C%20Windows-green)](https://pypi.org/project/protpy/)
 [![PythonV](https://img.shields.io/pypi/pyversions/protpy?logo=2)](https://pypi.org/project/protpy/)
+[![Documentation Status](https://readthedocs.org/projects/protpy/badge/?version=latest)](https://protpy.readthedocs.io/en/latest/?badge=latest)
 [![codecov](https://codecov.io/gh/amckenna41/protPy/graph/badge.svg?token=H508M9J13W)](https://codecov.io/gh/amckenna41/protPy)
 [![License: MIT](https://img.shields.io/badge/License-MIT-red.svg)](https://opensource.org/licenses/MIT)
 [![Issues](https://img.shields.io/github/issues/amckenna41/protpy)](https://github.com/amckenna41/protpy/issues)

{protpy-1.3.0 → protpy-1.4.0}/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.3.0'
+release = '1.4.0'
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration

{protpy-1.3.0 → protpy-1.4.0}/protpy/__init__.py

@@ -4,6 +4,7 @@ from .conjoint_triad import *
 from .ctd import *
 from .sequence_order import *
 from .utils import get_descriptor_info, list_descriptors, print_descriptor_info
+from .encode import all_descriptors
 
 #canonical amino acids available in the package
 amino_acids = ["A", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M", "N", "P",
@@ -11,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.3.0"
+__version__ = "1.4.0"
 __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'
@@ -25,8 +26,8 @@ __keywords__ = ["bioinformatics", "protein engineering", "python", "pypi", "mach
                 "structural descriptors", "pySAR"]
 __test_suite__ = "tests"
 
-#list of all available descriptors in protPy
-all_descriptors = ["amino_acid_composition", "dipeptide_composition", "tripeptide_composition",
+#list of all available descriptor names in protPy
+descriptor_names = ["amino_acid_composition", "dipeptide_composition", "tripeptide_composition",
     "gravy", "aromaticity", "instability_index", "isoelectric_point", "molecular_weight",
     "charge_distribution", "hydrophobic_polar_charged_composition", "secondary_structure_propensity",
     "kmer_composition", "reduced_alphabet_composition", "motif_composition",

protpy-1.4.0/protpy/encode.py

@@ -0,0 +1,203 @@
+################################################################################
+#############                      Encode                         ##############
+################################################################################
+
+from __future__ import annotations
+
+import pandas as pd
+
+from .composition import (
+    amino_acid_composition,
+    dipeptide_composition,
+    tripeptide_composition,
+    gravy,
+    aromaticity,
+    instability_index,
+    isoelectric_point,
+    molecular_weight,
+    charge_distribution,
+    hydrophobic_polar_charged_composition,
+    secondary_structure_propensity,
+    kmer_composition,
+    reduced_alphabet_composition,
+    motif_composition,
+    amino_acid_pair_composition,
+    aliphatic_index,
+    extinction_coefficient,
+    boman_index,
+    aggregation_propensity,
+    hydrophobic_moment,
+    shannon_entropy,
+    pseudo_amino_acid_composition,
+    amphiphilic_pseudo_amino_acid_composition,
+)
+from .autocorrelation import (
+    moreaubroto_autocorrelation,
+    moran_autocorrelation,
+    geary_autocorrelation,
+)
+from .conjoint_triad import conjoint_triad as _conjoint_triad
+from .ctd import ctd_
+from .sequence_order import (
+    sequence_order_coupling_number_all,
+    quasi_sequence_order_all,
+)
+from ._constants import _validate_sequence
+
+#descriptors that accept extra keyword arguments beyond sequence
+_PARAMETERISED_DESCRIPTORS: frozenset[str] = frozenset({
+    "charge_distribution",
+    "kmer_composition",
+    "reduced_alphabet_composition",
+    "motif_composition",
+    "aggregation_propensity",
+    "hydrophobic_moment",
+    "pseudo_amino_acid_composition",
+    "amphiphilic_pseudo_amino_acid_composition",
+    "moreaubroto_autocorrelation",
+    "moran_autocorrelation",
+    "geary_autocorrelation",
+    "ctd_",
+    "sequence_order_coupling_number_all",
+    "quasi_sequence_order_all",
+})
+
+
+def all_descriptors(sequence: str, params: dict[str, dict] | None = None) -> pd.DataFrame:
+    """
+    Calculate all available protpy descriptors for a protein sequence and
+    return them concatenated into a single DataFrame (1 x N_total).
+
+    The combined variants of multi-property descriptors are used to avoid
+    redundancy: ``ctd_`` is called with ``all_ctd=True`` (covers
+    ctd_composition, ctd_transition and ctd_distribution across all 7
+    properties), and ``sequence_order_coupling_number_all`` /
+    ``quasi_sequence_order_all`` cover both the schneider-wrede and grantham
+    distance matrices.
+
+    Parameters
+    ==========
+    :sequence: str
+        Protein sequence string (case-insensitive, canonical amino acids only).
+        Must be longer than 30 residues to satisfy the default lag requirements
+        of autocorrelation and sequence-order descriptors (unless overridden
+        via ``params``).
+
+    :params: dict[str, dict] | None (default=None)
+        Optional per-descriptor keyword arguments. Keys must be descriptor
+        function names; values are dicts of keyword arguments passed directly
+        to that descriptor. Unrecognised descriptor names raise a ``ValueError``.
+        Descriptors not present in ``params`` use their default parameter values.
+
+        Only the following descriptors accept extra parameters::
+
+            charge_distribution           → ph
+            kmer_composition              → k
+            reduced_alphabet_composition  → alphabet_size
+            motif_composition             → motifs
+            aggregation_propensity        → window, hydrophobicity_threshold,
+                                            charge_threshold
+            hydrophobic_moment            → window, angle
+            pseudo_amino_acid_composition → lamda, weight, properties
+            amphiphilic_pseudo_amino_acid_composition
+                                          → lamda, weight, properties
+            moreaubroto_autocorrelation   → lag, properties, normalize
+            moran_autocorrelation         → lag, properties, normalize
+            geary_autocorrelation         → lag, properties, normalize
+            ctd_                          → all_ctd
+            sequence_order_coupling_number_all → lag
+            quasi_sequence_order_all      → lag, weight
+
+        Example::
+
+            df = protpy.all_descriptors(seq, params={
+                'charge_distribution':            {'ph': 5.5},
+                'kmer_composition':               {'k': 3},
+                'pseudo_amino_acid_composition':  {'lamda': 10, 'weight': 0.1},
+                'moreaubroto_autocorrelation':    {'lag': 15, 'normalize': False},
+                'quasi_sequence_order_all':       {'lag': 20, 'weight': 0.2},
+            })
+
+    Returns
+    =======
+    :descriptors_df: pd.DataFrame
+        DataFrame of shape 1 x N containing all descriptor values, where N is
+        the total number of features across all descriptors.
+
+    Raises
+    ======
+    TypeError
+        If ``sequence`` is not a string, or if ``params`` is not a dict.
+    ValueError
+        If ``sequence`` is empty or contains non-canonical amino acid characters,
+        or if a key in ``params`` is not a recognised descriptor name.
+
+    Examples
+    ========
+    >>> import protpy
+    >>> seq = "MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGD"
+    >>> df = protpy.all_descriptors(seq)
+    >>> df.shape[0]
+    1
+    """
+    sequence = _validate_sequence(sequence)
+
+    if params is None:
+        params = {}
+
+    if not isinstance(params, dict):
+        raise TypeError(f"params must be a dict, got {type(params)}.")
+
+    unknown = set(params) - _PARAMETERISED_DESCRIPTORS
+    if unknown:
+        raise ValueError(
+            f"Unknown or non-parameterisable descriptor(s) in params: {sorted(unknown)}. "
+            f"Valid keys are: {sorted(_PARAMETERISED_DESCRIPTORS)}."
+        )
+
+    def _p(name: str) -> dict:
+        return params.get(name, {})
+
+    frames: list[pd.DataFrame] = []
+
+    # ── Composition ────────────────────────────────────────────────────────────
+    frames.append(amino_acid_composition(sequence))
+    frames.append(dipeptide_composition(sequence))
+    frames.append(tripeptide_composition(sequence))
+    frames.append(gravy(sequence))
+    frames.append(aromaticity(sequence))
+    frames.append(instability_index(sequence))
+    frames.append(isoelectric_point(sequence))
+    frames.append(molecular_weight(sequence))
+    frames.append(charge_distribution(sequence, **_p("charge_distribution")))
+    frames.append(hydrophobic_polar_charged_composition(sequence))
+    frames.append(secondary_structure_propensity(sequence))
+    frames.append(kmer_composition(sequence, **_p("kmer_composition")))
+    frames.append(reduced_alphabet_composition(sequence, **_p("reduced_alphabet_composition")))
+    frames.append(motif_composition(sequence, **_p("motif_composition")))
+    frames.append(amino_acid_pair_composition(sequence))
+    frames.append(aliphatic_index(sequence))
+    frames.append(extinction_coefficient(sequence))
+    frames.append(boman_index(sequence))
+    frames.append(aggregation_propensity(sequence, **_p("aggregation_propensity")))
+    frames.append(hydrophobic_moment(sequence, **_p("hydrophobic_moment")))
+    frames.append(shannon_entropy(sequence))
+    frames.append(pseudo_amino_acid_composition(sequence, **_p("pseudo_amino_acid_composition")))
+    frames.append(amphiphilic_pseudo_amino_acid_composition(sequence, **_p("amphiphilic_pseudo_amino_acid_composition")))
+
+    # ── Autocorrelation ────────────────────────────────────────────────────────
+    frames.append(moreaubroto_autocorrelation(sequence, **_p("moreaubroto_autocorrelation")))
+    frames.append(moran_autocorrelation(sequence, **_p("moran_autocorrelation")))
+    frames.append(geary_autocorrelation(sequence, **_p("geary_autocorrelation")))
+
+    # ── Conjoint Triad ─────────────────────────────────────────────────────────
+    frames.append(_conjoint_triad(sequence))
+
+    # ── CTD (Composition + Transition + Distribution across all 7 properties) ──
+    frames.append(ctd_(sequence, all_ctd=True, **_p("ctd_")))
+
+    # ── Sequence Order ─────────────────────────────────────────────────────────
+    frames.append(sequence_order_coupling_number_all(sequence, **_p("sequence_order_coupling_number_all")))
+    frames.append(quasi_sequence_order_all(sequence, **_p("quasi_sequence_order_all")))
+
+    return pd.concat(frames, axis=1)

{protpy-1.3.0 → protpy-1.4.0/protpy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: protpy
-Version: 1.3.0
+Version: 1.4.0
 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>
@@ -54,6 +54,7 @@ Dynamic: license-file
 [![pytest](https://github.com/amckenna41/protpy/workflows/Building%20and%20Testing/badge.svg)](https://github.com/amckenna41/protpy/actions?query=workflowBuilding%20and%20Testing)
 [![Platforms](https://img.shields.io/badge/platforms-linux%2C%20macOS%2C%20Windows-green)](https://pypi.org/project/protpy/)
 [![PythonV](https://img.shields.io/pypi/pyversions/protpy?logo=2)](https://pypi.org/project/protpy/)
+[![Documentation Status](https://readthedocs.org/projects/protpy/badge/?version=latest)](https://protpy.readthedocs.io/en/latest/?badge=latest)
 [![codecov](https://codecov.io/gh/amckenna41/protPy/graph/badge.svg?token=H508M9J13W)](https://codecov.io/gh/amckenna41/protPy)
 [![License: MIT](https://img.shields.io/badge/License-MIT-red.svg)](https://opensource.org/licenses/MIT)
 [![Issues](https://img.shields.io/github/issues/amckenna41/protpy)](https://github.com/amckenna41/protpy/issues)

{protpy-1.3.0 → protpy-1.4.0}/protpy.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ protpy/autocorrelation.py
 protpy/composition.py
 protpy/conjoint_triad.py
 protpy/ctd.py
+protpy/encode.py
 protpy/sequence_order.py
 protpy/utils.py
 protpy.egg-info/PKG-INFO
@@ -24,6 +25,7 @@ tests/test_autocorrelation.py
 tests/test_composition.py
 tests/test_conjoint_triad.py
 tests/test_ctd.py
+tests/test_encode.py
 tests/test_protpy.py
 tests/test_sequence_order.py
 tests/test_utils.py

{protpy-1.3.0 → protpy-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "protpy"
-version = "1.3.0"
+version = "1.4.0"
 description = "Python package for generating various biochemical, physicochemical and structural descriptors/features of protein sequences."
 readme = "README.md"
 license = { text = "MIT" }

protpy-1.4.0/tests/test_encode.py

@@ -0,0 +1,304 @@
+###########################################################################
+##################    protPy - Encode Module Tests    ####################
+###########################################################################
+
+import pandas as pd
+import numpy as np
+import os
+import unittest
+from unittest.mock import patch
+from Bio import SeqIO
+unittest.TestLoader.sortTestMethodsUsing = None
+
+import protpy as protpy
+
+
+def _mock_df(n_cols, named_values=None):
+    """
+    Return a (1 x n_cols) mock DataFrame.
+    First column is always 'A', last is 'QSO_Grant50'.
+    Any keys in named_values are inserted as named columns with their given value;
+    remaining columns are zero-filled filler to reach exactly n_cols.
+    """
+    named = named_values or {}
+    special = {"A", "QSO_Grant50"} | set(named.keys())
+    filler_count = n_cols - len(special)
+    filler = [f"feat_{i}" for i in range(filler_count)]
+    middle = sorted(special - {"A", "QSO_Grant50"}) + filler
+    cols = ["A"] + middle + ["QSO_Grant50"]
+    df = pd.DataFrame(np.zeros((1, len(cols))), columns=cols)
+    for col, val in named.items():
+        df[col] = val
+    return df
+
+
+class ProtpyEncodeTests(unittest.TestCase):
+    """
+    Test suite for testing the encode module and all_descriptors function
+    in the protpy package.
+
+    Test Cases
+    ----------
+    test_all_descriptors_default:
+        testing correct all_descriptors output shape, type and values using
+        default parameters across all four test protein sequences (mocked).
+    test_all_descriptors_custom_params:
+        testing that custom per-descriptor parameters are correctly applied
+        and produce expected changes in output shape and values (mocked).
+    test_all_descriptors_params_validation:
+        testing that invalid params inputs raise the correct errors, including
+        unknown descriptor names, non-parameterisable descriptors, and wrong
+        params type.
+    test_all_descriptors_invalid_sequence:
+        testing that invalid protein sequence inputs raise the correct errors.
+    """
+    def setUp(self):
+        """ Import protein sequences from test fasta files using Biopython package. """
+        #using next() to get first item (protein seq) from SeqIO Generator
+        with open(os.path.join("tests", "test_data", "test_fasta1.fasta")) as pro:
+            self.protein_seq1 = str(next(SeqIO.parse(pro, 'fasta')).seq)
+
+        with open(os.path.join("tests", "test_data", "test_fasta2.fasta")) as pro:
+            self.protein_seq2 = str(next(SeqIO.parse(pro, 'fasta')).seq)
+
+        with open(os.path.join("tests", "test_data", "test_fasta3.fasta")) as pro:
+            self.protein_seq3 = str(next(SeqIO.parse(pro, 'fasta')).seq)
+
+        with open(os.path.join("tests", "test_data", "test_fasta4.fasta")) as pro:
+            self.protein_seq4 = str(next(SeqIO.parse(pro, 'fasta')).seq)
+
+    @patch('protpy.all_descriptors')
+    def test_all_descriptors_default(self, mock_all_desc):
+        """ Testing all_descriptors with default parameters across all four sequences (mocked). """
+        expected_shape = (1, 10757)
+        expected_first_col = "A"
+        expected_last_col = "QSO_Grant50"
+
+        df_seq1 = _mock_df(10757, {"A": 6.693, "MBAuto_CIDH920105_1": -0.052, "QSO_Grant50": 0.034943})
+        df_seq2 = _mock_df(10757, {"A": 8.057, "MBAuto_CIDH920105_1":  0.228, "QSO_Grant50": 0.031915})
+        df_seq3 = _mock_df(10757, {"A": 5.263, "MBAuto_CIDH920105_1":  0.212, "QSO_Grant50": 0.028037})
+        df_seq4 = _mock_df(10757, {"A": 8.831, "MBAuto_CIDH920105_1":  0.246, "QSO_Grant50": 0.031954})
+        # 5th call (params=None) returns the same object as call 1 so .equals() holds
+        mock_all_desc.side_effect = [df_seq1, df_seq2, df_seq3, df_seq4, df_seq1]
+
+#1.)
+        all_desc_seq1 = protpy.all_descriptors(self.protein_seq1)
+
+        self.assertIsInstance(all_desc_seq1, pd.DataFrame,
+            'Expected output to be of type DataFrame, got {}.'.format(type(all_desc_seq1)))
+        self.assertEqual(all_desc_seq1.shape, expected_shape,
+            'Expected output shape {}, got {}.'.format(expected_shape, all_desc_seq1.shape))
+        self.assertEqual(list(all_desc_seq1.columns)[0], expected_first_col,
+            'Expected first column to be {}, got {}.'.format(expected_first_col, list(all_desc_seq1.columns)[0]))
+        self.assertEqual(list(all_desc_seq1.columns)[-1], expected_last_col,
+            'Expected last column to be {}, got {}.'.format(expected_last_col, list(all_desc_seq1.columns)[-1]))
+        self.assertTrue(all_desc_seq1.any().isnull().sum() == 0,
+            'Expected output to contain no null values.')
+        self.assertEqual(all_desc_seq1["A"].values[0], 6.693,
+            'Expected amino acid composition A value of 6.693 for seq1, got {}.'.format(all_desc_seq1["A"].values[0]))
+        self.assertEqual(all_desc_seq1["MBAuto_CIDH920105_1"].values[0], -0.052,
+            'Expected MBAuto_CIDH920105_1 value of -0.052 for seq1, got {}.'.format(all_desc_seq1["MBAuto_CIDH920105_1"].values[0]))
+        self.assertAlmostEqual(all_desc_seq1["QSO_Grant50"].values[0], 0.034943, places=5,
+            msg='Expected QSO_Grant50 value of ~0.034943 for seq1, got {}.'.format(all_desc_seq1["QSO_Grant50"].values[0]))
+#2.)
+        all_desc_seq2 = protpy.all_descriptors(self.protein_seq2)
+
+        self.assertIsInstance(all_desc_seq2, pd.DataFrame,
+            'Expected output to be of type DataFrame, got {}.'.format(type(all_desc_seq2)))
+        self.assertEqual(all_desc_seq2.shape, expected_shape,
+            'Expected output shape {}, got {}.'.format(expected_shape, all_desc_seq2.shape))
+        self.assertEqual(list(all_desc_seq2.columns)[0], expected_first_col,
+            'Expected first column to be {}, got {}.'.format(expected_first_col, list(all_desc_seq2.columns)[0]))
+        self.assertEqual(list(all_desc_seq2.columns)[-1], expected_last_col,
+            'Expected last column to be {}, got {}.'.format(expected_last_col, list(all_desc_seq2.columns)[-1]))
+        self.assertTrue(all_desc_seq2.any().isnull().sum() == 0,
+            'Expected output to contain no null values.')
+        self.assertEqual(all_desc_seq2["A"].values[0], 8.057,
+            'Expected amino acid composition A value of 8.057 for seq2, got {}.'.format(all_desc_seq2["A"].values[0]))
+        self.assertEqual(all_desc_seq2["MBAuto_CIDH920105_1"].values[0], 0.228,
+            'Expected MBAuto_CIDH920105_1 value of 0.228 for seq2, got {}.'.format(all_desc_seq2["MBAuto_CIDH920105_1"].values[0]))
+        self.assertAlmostEqual(all_desc_seq2["QSO_Grant50"].values[0], 0.031915, places=5,
+            msg='Expected QSO_Grant50 value of ~0.031915 for seq2, got {}.'.format(all_desc_seq2["QSO_Grant50"].values[0]))
+#3.)
+        all_desc_seq3 = protpy.all_descriptors(self.protein_seq3)
+
+        self.assertIsInstance(all_desc_seq3, pd.DataFrame,
+            'Expected output to be of type DataFrame, got {}.'.format(type(all_desc_seq3)))
+        self.assertEqual(all_desc_seq3.shape, expected_shape,
+            'Expected output shape {}, got {}.'.format(expected_shape, all_desc_seq3.shape))
+        self.assertEqual(list(all_desc_seq3.columns)[0], expected_first_col,
+            'Expected first column to be {}, got {}.'.format(expected_first_col, list(all_desc_seq3.columns)[0]))
+        self.assertEqual(list(all_desc_seq3.columns)[-1], expected_last_col,
+            'Expected last column to be {}, got {}.'.format(expected_last_col, list(all_desc_seq3.columns)[-1]))
+        self.assertTrue(all_desc_seq3.any().isnull().sum() == 0,
+            'Expected output to contain no null values.')
+        self.assertEqual(all_desc_seq3["A"].values[0], 5.263,
+            'Expected amino acid composition A value of 5.263 for seq3, got {}.'.format(all_desc_seq3["A"].values[0]))
+        self.assertEqual(all_desc_seq3["MBAuto_CIDH920105_1"].values[0], 0.212,
+            'Expected MBAuto_CIDH920105_1 value of 0.212 for seq3, got {}.'.format(all_desc_seq3["MBAuto_CIDH920105_1"].values[0]))
+        self.assertAlmostEqual(all_desc_seq3["QSO_Grant50"].values[0], 0.028037, places=5,
+            msg='Expected QSO_Grant50 value of ~0.028037 for seq3, got {}.'.format(all_desc_seq3["QSO_Grant50"].values[0]))
+#4.)
+        all_desc_seq4 = protpy.all_descriptors(self.protein_seq4)
+
+        self.assertIsInstance(all_desc_seq4, pd.DataFrame,
+            'Expected output to be of type DataFrame, got {}.'.format(type(all_desc_seq4)))
+        self.assertEqual(all_desc_seq4.shape, expected_shape,
+            'Expected output shape {}, got {}.'.format(expected_shape, all_desc_seq4.shape))
+        self.assertEqual(list(all_desc_seq4.columns)[0], expected_first_col,
+            'Expected first column to be {}, got {}.'.format(expected_first_col, list(all_desc_seq4.columns)[0]))
+        self.assertEqual(list(all_desc_seq4.columns)[-1], expected_last_col,
+            'Expected last column to be {}, got {}.'.format(expected_last_col, list(all_desc_seq4.columns)[-1]))
+        self.assertTrue(all_desc_seq4.any().isnull().sum() == 0,
+            'Expected output to contain no null values.')
+        self.assertEqual(all_desc_seq4["A"].values[0], 8.831,
+            'Expected amino acid composition A value of 8.831 for seq4, got {}.'.format(all_desc_seq4["A"].values[0]))
+        self.assertEqual(all_desc_seq4["MBAuto_CIDH920105_1"].values[0], 0.246,
+            'Expected MBAuto_CIDH920105_1 value of 0.246 for seq4, got {}.'.format(all_desc_seq4["MBAuto_CIDH920105_1"].values[0]))
+        self.assertAlmostEqual(all_desc_seq4["QSO_Grant50"].values[0], 0.031954, places=5,
+            msg='Expected QSO_Grant50 value of ~0.031954 for seq4, got {}.'.format(all_desc_seq4["QSO_Grant50"].values[0]))
+#5.) passing None for params is equivalent to default
+        all_desc_none_params = protpy.all_descriptors(self.protein_seq1, params=None)
+        self.assertTrue(all_desc_none_params.equals(all_desc_seq1),
+            'Expected params=None to produce same output as default params.')
+
+        self.assertEqual(mock_all_desc.call_count, 5,
+            'Expected all_descriptors to be called exactly 5 times, got {}.'.format(mock_all_desc.call_count))
+
+    @patch('protpy.all_descriptors')
+    def test_all_descriptors_custom_params(self, mock_all_desc):
+        """ Testing all_descriptors with custom per-descriptor parameters (mocked). """
+        df_kmer_k3        = _mock_df(18357)
+        df_kmer_default   = _mock_df(10757)
+        df_charge_custom  = _mock_df(10757, {"PositiveCharge": 110.396})
+        df_charge_default = _mock_df(10757, {"PositiveCharge": 85.0})
+        df_custom_lag     = _mock_df(10337)
+        df_ra2            = _mock_df(10753)
+        df_combined       = _mock_df(17937)
+        mock_all_desc.side_effect = [
+            df_kmer_k3, df_kmer_default,
+            df_charge_custom, df_charge_default,
+            df_custom_lag, df_ra2, df_combined,
+        ]
+
+#1.) kmer_composition k=3 increases feature count from 400 to 8000
+        kmer_k3 = protpy.all_descriptors(self.protein_seq1, params={
+            'kmer_composition': {'k': 3},
+        })
+        kmer_default = protpy.all_descriptors(self.protein_seq1)
+        #k=3 adds 7600 extra features (8000-400)
+        self.assertEqual(kmer_k3.shape, (1, kmer_default.shape[1] + 7600),
+            'Expected k=3 to add 7600 features, shape {}, got {}.'.format(
+                (1, kmer_default.shape[1] + 7600), kmer_k3.shape))
+        self.assertIsInstance(kmer_k3, pd.DataFrame,
+            'Expected output to be of type DataFrame, got {}.'.format(type(kmer_k3)))
+        self.assertTrue(kmer_k3.any().isnull().sum() == 0,
+            'Expected output to contain no null values.')
+#2.) charge_distribution ph=5.5 changes PositiveCharge vs default ph=7.4
+        charge_custom = protpy.all_descriptors(self.protein_seq1, params={
+            'charge_distribution': {'ph': 5.5},
+        })
+        charge_default = protpy.all_descriptors(self.protein_seq1)
+        self.assertIsInstance(charge_custom, pd.DataFrame,
+            'Expected output to be of type DataFrame, got {}.'.format(type(charge_custom)))
+        self.assertNotEqual(
+            charge_custom["PositiveCharge"].values[0],
+            charge_default["PositiveCharge"].values[0],
+            'Expected PositiveCharge to differ between ph=5.5 and ph=7.4 (default).')
+        self.assertEqual(charge_custom["PositiveCharge"].values[0], 110.396,
+            'Expected PositiveCharge of 110.396 at ph=5.5 for seq1, got {}.'.format(
+                charge_custom["PositiveCharge"].values[0]))
+#3.) reduced lag on autocorrelation and sequence-order descriptors reduces feature count
+        lag = 15
+        custom_lag = protpy.all_descriptors(self.protein_seq1, params={
+            'moreaubroto_autocorrelation':        {'lag': lag},
+            'moran_autocorrelation':              {'lag': lag},
+            'geary_autocorrelation':              {'lag': lag},
+            'sequence_order_coupling_number_all': {'lag': lag},
+            'quasi_sequence_order_all':           {'lag': lag},
+        })
+        self.assertIsInstance(custom_lag, pd.DataFrame,
+            'Expected output to be of type DataFrame, got {}.'.format(type(custom_lag)))
+        #each autocorrelation descriptor loses (30-15)*8=120 features, socn_all loses 30,
+        #qso_all loses (20+30)*2-(20+15)*2=100-70=30; total reduction=120*3+30+30=420
+        self.assertEqual(custom_lag.shape, (1, kmer_default.shape[1] - 420),
+            'Expected lag=15 to reduce total by 420, shape {}, got {}.'.format(
+                (1, kmer_default.shape[1] - 420), custom_lag.shape))
+        self.assertTrue(custom_lag.any().isnull().sum() == 0,
+            'Expected output to contain no null values.')
+#4.) reduced_alphabet_composition alphabet_size=2 reduces feature count by 4 (6-2)
+        ra2 = protpy.all_descriptors(self.protein_seq1, params={
+            'reduced_alphabet_composition': {'alphabet_size': 2},
+        })
+        self.assertEqual(ra2.shape, (1, kmer_default.shape[1] - 4),
+            'Expected alphabet_size=2 to reduce total by 4, got shape {}.'.format(ra2.shape))
+        self.assertTrue(ra2.any().isnull().sum() == 0,
+            'Expected output to contain no null values.')
+#5.) multiple custom params applied simultaneously
+        combined = protpy.all_descriptors(self.protein_seq2, params={
+            'charge_distribution':            {'ph': 5.5},
+            'kmer_composition':               {'k': 3},
+            'moreaubroto_autocorrelation':    {'lag': 15},
+            'moran_autocorrelation':          {'lag': 15},
+            'geary_autocorrelation':          {'lag': 15},
+            'sequence_order_coupling_number_all': {'lag': 15},
+            'quasi_sequence_order_all':       {'lag': 15},
+        })
+        self.assertIsInstance(combined, pd.DataFrame,
+            'Expected output to be of type DataFrame, got {}.'.format(type(combined)))
+        self.assertEqual(combined.shape, (1, 17937),
+            'Expected combined custom params shape (1, 17937), got {}.'.format(combined.shape))
+        self.assertTrue(combined.any().isnull().sum() == 0,
+            'Expected output to contain no null values.')
+
+        self.assertEqual(mock_all_desc.call_count, 7,
+            'Expected all_descriptors to be called exactly 7 times, got {}.'.format(mock_all_desc.call_count))
+
+    def test_all_descriptors_params_validation(self):
+        """ Testing that invalid params inputs raise the correct errors. """
+        # Validation is fast: errors are raised before any descriptor computation.
+#1.) unknown descriptor name raises ValueError
+        with self.assertRaises(ValueError):
+            protpy.all_descriptors(self.protein_seq1, params={'unknown_descriptor': {'k': 2}})
+#2.) a descriptor that takes no extra parameters raises ValueError
+        with self.assertRaises(ValueError):
+            protpy.all_descriptors(self.protein_seq1, params={'amino_acid_composition': {}})
+        with self.assertRaises(ValueError):
+            protpy.all_descriptors(self.protein_seq1, params={'conjoint_triad': {}})
+        with self.assertRaises(ValueError):
+            protpy.all_descriptors(self.protein_seq1, params={'gravy': {}})
+#3.) params of wrong type raises TypeError
+        with self.assertRaises(TypeError):
+            protpy.all_descriptors(self.protein_seq1, params="lag=15")
+        with self.assertRaises(TypeError):
+            protpy.all_descriptors(self.protein_seq1, params=["kmer_composition"])
+        with self.assertRaises(TypeError):
+            protpy.all_descriptors(self.protein_seq1, params=123)
+#4.) misspelled descriptor name raises ValueError with a useful message
+        try:
+            protpy.all_descriptors(self.protein_seq1, params={'kmer_compostion': {'k': 3}})
+            self.fail('Expected ValueError for misspelled descriptor name.')
+        except ValueError as e:
+            self.assertIn('kmer_compostion', str(e),
+                'Expected error message to name the unrecognised key, got: {}'.format(e))
+
+    def test_all_descriptors_invalid_sequence(self):
+        """ Testing that invalid protein sequence inputs raise the correct errors. """
+        # Validation is fast: errors are raised before any descriptor computation.
+#1.) sequence containing non-canonical amino acid characters raises ValueError
+        with self.assertRaises(ValueError):
+            protpy.all_descriptors("ABCDEF")
+        with self.assertRaises(ValueError):
+            protpy.all_descriptors("OOOOO")
+        with self.assertRaises(ValueError):
+            protpy.all_descriptors("")
+#2.) non-string sequence raises TypeError
+        with self.assertRaises(TypeError):
+            protpy.all_descriptors(12345)
+        with self.assertRaises(TypeError):
+            protpy.all_descriptors(True)
+        with self.assertRaises(TypeError):
+            protpy.all_descriptors(["ACDEFG"])
+#3.) invalid sequence with otherwise valid custom params still raises ValueError
+        with self.assertRaises(ValueError):
+            protpy.all_descriptors("ABCDEF", params={'kmer_composition': {'k': 3}})

{protpy-1.3.0 → protpy-1.4.0}/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.3.0", 
-            "protpy version is not correct, expected version 1.3.0, got version {}".format(protpy.__version__))
+        self.assertEqual(protpy.__version__, "1.4.0",
+            "protpy version is not correct, expected version 1.4.0, 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", 
@@ -47,84 +47,84 @@ class ProtpyTests(unittest.TestCase):
 
     def test_valid_descriptors(self):
         """ Testing correct list of available descriptors is included in package attribute. """
-        self.assertEqual(len(protpy.all_descriptors), 36, 
-            "Expected there to be 36 total descriptors, got {}.".format(len(protpy.all_descriptors)))
-        self.assertIsInstance(protpy.all_descriptors, list, 
-            "all_descriptors should be of type list, got {}.".format(type(protpy.all_descriptors)))
+        self.assertEqual(len(protpy.descriptor_names), 36, 
+            "Expected there to be 36 total descriptors, got {}.".format(len(protpy.descriptor_names)))
+        self.assertIsInstance(protpy.descriptor_names, list, 
+            "all_descriptors should be of type list, got {}.".format(type(protpy.descriptor_names)))
         # composition descriptors
-        self.assertIn('amino_acid_composition', protpy.all_descriptors, 
+        self.assertIn('amino_acid_composition', protpy.descriptor_names, 
             "amino_acid_composition should be in available descriptors list.")
-        self.assertIn('dipeptide_composition', protpy.all_descriptors, 
+        self.assertIn('dipeptide_composition', protpy.descriptor_names, 
             "dipeptide_composition should be in available descriptors list.")
-        self.assertIn('tripeptide_composition', protpy.all_descriptors,
+        self.assertIn('tripeptide_composition', protpy.descriptor_names,
             "tripeptide_composition should be in available descriptors list.")
-        self.assertIn('gravy', protpy.all_descriptors,
+        self.assertIn('gravy', protpy.descriptor_names,
             "gravy should be in available descriptors list.")
-        self.assertIn('aromaticity', protpy.all_descriptors,
+        self.assertIn('aromaticity', protpy.descriptor_names,
             "aromaticity should be in available descriptors list.")
-        self.assertIn('instability_index', protpy.all_descriptors,
+        self.assertIn('instability_index', protpy.descriptor_names,
             "instability_index should be in available descriptors list.")
-        self.assertIn('isoelectric_point', protpy.all_descriptors,
+        self.assertIn('isoelectric_point', protpy.descriptor_names,
             "isoelectric_point should be in available descriptors list.")
-        self.assertIn('molecular_weight', protpy.all_descriptors,
+        self.assertIn('molecular_weight', protpy.descriptor_names,
             "molecular_weight should be in available descriptors list.")
-        self.assertIn('charge_distribution', protpy.all_descriptors,
+        self.assertIn('charge_distribution', protpy.descriptor_names,
             "charge_distribution should be in available descriptors list.")
-        self.assertIn('hydrophobic_polar_charged_composition', protpy.all_descriptors,
+        self.assertIn('hydrophobic_polar_charged_composition', protpy.descriptor_names,
             "hydrophobic_polar_charged_composition should be in available descriptors list.")
-        self.assertIn('secondary_structure_propensity', protpy.all_descriptors,
+        self.assertIn('secondary_structure_propensity', protpy.descriptor_names,
             "secondary_structure_propensity should be in available descriptors list.")
-        self.assertIn('kmer_composition', protpy.all_descriptors,
+        self.assertIn('kmer_composition', protpy.descriptor_names,
             "kmer_composition should be in available descriptors list.")
-        self.assertIn('reduced_alphabet_composition', protpy.all_descriptors,
+        self.assertIn('reduced_alphabet_composition', protpy.descriptor_names,
             "reduced_alphabet_composition should be in available descriptors list.")
-        self.assertIn('motif_composition', protpy.all_descriptors,
+        self.assertIn('motif_composition', protpy.descriptor_names,
             "motif_composition should be in available descriptors list.")
-        self.assertIn('amino_acid_pair_composition', protpy.all_descriptors,
+        self.assertIn('amino_acid_pair_composition', protpy.descriptor_names,
             "amino_acid_pair_composition should be in available descriptors list.")
-        self.assertIn('aliphatic_index', protpy.all_descriptors,
+        self.assertIn('aliphatic_index', protpy.descriptor_names,
             "aliphatic_index should be in available descriptors list.")
-        self.assertIn('extinction_coefficient', protpy.all_descriptors,
+        self.assertIn('extinction_coefficient', protpy.descriptor_names,
             "extinction_coefficient should be in available descriptors list.")
-        self.assertIn('boman_index', protpy.all_descriptors,
+        self.assertIn('boman_index', protpy.descriptor_names,
             "boman_index should be in available descriptors list.")
-        self.assertIn('aggregation_propensity', protpy.all_descriptors,
+        self.assertIn('aggregation_propensity', protpy.descriptor_names,
             "aggregation_propensity should be in available descriptors list.")
-        self.assertIn('hydrophobic_moment', protpy.all_descriptors,
+        self.assertIn('hydrophobic_moment', protpy.descriptor_names,
             "hydrophobic_moment should be in available descriptors list.")
-        self.assertIn('pseudo_amino_acid_composition', protpy.all_descriptors,
+        self.assertIn('pseudo_amino_acid_composition', protpy.descriptor_names,
             "pseudo_amino_acid_composition should be in available descriptors list.")
-        self.assertIn('amphiphilic_pseudo_amino_acid_composition', protpy.all_descriptors, 
+        self.assertIn('amphiphilic_pseudo_amino_acid_composition', protpy.descriptor_names, 
             "amphiphilic_pseudo_amino_acid_composition should be in available descriptors list.")
         # autocorrelation descriptors
-        self.assertIn('moreaubroto_autocorrelation', protpy.all_descriptors,
+        self.assertIn('moreaubroto_autocorrelation', protpy.descriptor_names,
             "moreaubroto_autocorrelation should be in available descriptors list.")
-        self.assertIn('moran_autocorrelation', protpy.all_descriptors, 
+        self.assertIn('moran_autocorrelation', protpy.descriptor_names, 
             "moran_autocorrelation should be in available descriptors list.")
-        self.assertIn('geary_autocorrelation', protpy.all_descriptors,
+        self.assertIn('geary_autocorrelation', protpy.descriptor_names,
             "geary_autocorrelation should be in available descriptors list.")
         # conjoint triad descriptor
-        self.assertIn('conjoint_triad', protpy.all_descriptors,
+        self.assertIn('conjoint_triad', protpy.descriptor_names,
             "conjoint_triad should be in available descriptors list.")
         # CTD descriptors
-        self.assertIn('ctd_composition', protpy.all_descriptors,
+        self.assertIn('ctd_composition', protpy.descriptor_names,
             "ctd_composition should be in available descriptors list.")
-        self.assertIn('ctd_transition', protpy.all_descriptors,
+        self.assertIn('ctd_transition', protpy.descriptor_names,
             "ctd_transition should be in available descriptors list.")
-        self.assertIn('ctd_distribution', protpy.all_descriptors,
+        self.assertIn('ctd_distribution', protpy.descriptor_names,
             "ctd_distribution should be in available descriptors list.")
-        self.assertIn('ctd_', protpy.all_descriptors,
+        self.assertIn('ctd_', protpy.descriptor_names,
             "ctd_ should be in available descriptors list.")
         # sequence order descriptors
-        self.assertIn('sequence_order_coupling_number_', protpy.all_descriptors,
+        self.assertIn('sequence_order_coupling_number_', protpy.descriptor_names,
             "sequence_order_coupling_number_ should be in available descriptors list.")
-        self.assertIn('sequence_order_coupling_number', protpy.all_descriptors,
+        self.assertIn('sequence_order_coupling_number', protpy.descriptor_names,
             "sequence_order_coupling_number should be in available descriptors list.")
-        self.assertIn('sequence_order_coupling_number_all', protpy.all_descriptors,
+        self.assertIn('sequence_order_coupling_number_all', protpy.descriptor_names,
             "sequence_order_coupling_number_all should be in available descriptors list.")
-        self.assertIn('quasi_sequence_order', protpy.all_descriptors,
+        self.assertIn('quasi_sequence_order', protpy.descriptor_names,
             "quasi_sequence_order should be in available descriptors list.")
-        self.assertIn('quasi_sequence_order_all', protpy.all_descriptors,
+        self.assertIn('quasi_sequence_order_all', protpy.descriptor_names,
             "quasi_sequence_order_all should be in available descriptors list.")
-        self.assertIn('shannon_entropy', protpy.all_descriptors,
+        self.assertIn('shannon_entropy', protpy.descriptor_names,
             "shannon_entropy should be in available descriptors list.")

{protpy-1.3.0 → protpy-1.4.0}/tests/test_utils.py

@@ -86,12 +86,12 @@ class ProtpyUtilsTests(unittest.TestCase):
 
     def test_registry_completeness(self):
         """All 36 descriptor names exported by protpy appear in _DESCRIPTOR_REGISTRY."""
-        missing = [n for n in protpy.all_descriptors if n not in _DESCRIPTOR_REGISTRY]
+        missing = [n for n in protpy.descriptor_names if n not in _DESCRIPTOR_REGISTRY]
         self.assertEqual(
             missing, [],
             f"Descriptors in all_descriptors but missing from registry: {missing}",
         )
-        self.assertEqual(len(_DESCRIPTOR_REGISTRY), len(protpy.all_descriptors),
+        self.assertEqual(len(_DESCRIPTOR_REGISTRY), len(protpy.descriptor_names),
             "Registry length doesn't match len(all_descriptors).")
 
     def test_registry_schema(self):
@@ -204,7 +204,7 @@ class ProtpyUtilsTests(unittest.TestCase):
         # Result is sorted
         self.assertEqual(descriptors, sorted(descriptors))
         # Every name in all_descriptors appears in the result
-        for name in protpy.all_descriptors:
+        for name in protpy.descriptor_names:
             self.assertIn(name, descriptors)
 
     def test_list_descriptors_by_category(self):