linting + actions

Author: pgarrett-scripps

pyproject.toml

@@ -36,5 +36,11 @@ version = {attr = "peptacular.__version__"}
 [tool.pylint]
 max-line-length = 120
 fail-under = 9.5
-good-names = ["db", "i", "j", "aa", "n", "k", "p", "Na", "Nb", "Nc", "Nx", "Ny", "Nz", "mz"]
-extension-pkg-whitelist='pydantic'
+good-names = ["db", "i", "j", "aa", "n", "k", "p", "Na", "Nb", "Nc", "Nx", "Ny", "Nz", "mz", "k", "v",
+    "f", "d", "m", "s", "r"]
+extension-pkg-whitelist = 'pydantic'
+max-branches = 50  # Increase the number of allowed branches
+max-locals = 30    # Increase the number of allowed local variables
+max-attributes = 50 # Increase the number of allowed attributes
+max-statements = 100  # Increase the number of allowed statements in a function
+max-args = 10  # Increase the number of allowed arguments in a function

src/peptacular/digestion.py

@@ -14,7 +14,7 @@
 
 """
 from dataclasses import dataclass
-from typing import Union, List, Optional, TypeAlias, Literal, Tuple, Generator, Iterable
+from typing import Union, List, Optional, Literal, Tuple, Generator, Iterable
 
 from peptacular.spans import Span
 from peptacular.constants import PROTEASES_COMPILED
@@ -23,7 +23,7 @@
 from peptacular.sequence.sequence_funcs import sequence_to_annotation
 from peptacular.util import get_regex_match_indices
 
-DigestReturnType: TypeAlias = Literal["str", "annotation", "span", "str-span", "annotation-span"]
+DigestReturnType = Literal["str", "annotation", "span", "str-span", "annotation-span"]
 
 DIGEST_RETURN_TYPING = Union[Generator[str, None, None], Generator[ProFormaAnnotation, None, None],
 Generator[Span, None, None], Generator[Tuple[str, Span], None, None],
@@ -113,8 +113,8 @@ def get_left_semi_enzymatic_sequences(sequence: Union[str, ProFormaAnnotation],
     else:
         raise ValueError(f"Unsupported input type: {type(sequence)}")
 
-    s = (0, len(annotation), 0)
-    spans = build_left_semi_spans(span=s, min_len=min_len, max_len=max_len)
+    span = (0, len(annotation), 0)
+    spans = build_left_semi_spans(span=span, min_len=min_len, max_len=max_len)
 
     return _return_digested_sequences(annotation, spans, return_type)
 
@@ -198,7 +198,8 @@ def get_semi_enzymatic_sequences(sequence: Union[str, ProFormaAnnotation],
     .. code-block:: python
 
         # Equivalent to build_left_semi_sequences + build_right_semi_sequences
-        >>> res = list(get_left_semi_enzymatic_sequences('PEPTIDE')) + list(get_right_semi_enzymatic_sequences('PEPTIDE'))
+        >>> res = list(get_left_semi_enzymatic_sequences('PEPTIDE'))
+        >>> res += list(get_right_semi_enzymatic_sequences('PEPTIDE'))
         >>> list(get_semi_enzymatic_sequences('PEPTIDE')) == list(res)
         True
 
@@ -366,7 +367,7 @@ def digest(sequence: Union[str, ProFormaAnnotation],
         ['TIDER', 'TIDERTIDEK', 'TIDERTIDEKTIDE', 'TIDEK', 'TIDEKTIDE', 'TIDE']
 
         # Inlcude spans in the returned values:
-        >>> list(digest(sequence='TIDERTIDEKTIDE', enzyme_regex='trypsin/P', missed_cleavages=0, return_type='str-span'))
+        >>> list(digest(sequence='TIDERTIDEKTIDE', enzyme_regex='trypsin/P', return_type='str-span'))
         [('TIDER', (0, 5, 0)), ('TIDEK', (5, 10, 0)), ('TIDE', (10, 14, 0))]
 
         # Or specify a regular expression:

src/peptacular/fragmentation.py

@@ -5,7 +5,7 @@
 import re
 from dataclasses import dataclass
 from functools import cached_property
-from typing import List, Union, TypeAlias, Literal, Optional, Tuple, Set
+from typing import List, Union, Literal, Optional, Tuple, Set
 
 from peptacular.proforma.proforma_parser import ProFormaAnnotation
 from peptacular.constants import FORWARD_ION_TYPES, BACKWARD_ION_TYPES, INTERNAL_ION_TYPES, TERMINAL_ION_TYPES
@@ -114,7 +114,7 @@ def to_dict(self):
         }
 
 
-FragmentReturnType: TypeAlias = Literal["fragment", "mass", "mz", "label", "mass-label", "mz-label"]
+FragmentReturnType = Literal["fragment", "mass", "mz", "label", "mass-label", "mz-label"]
 FRAGMENT_RETURN_TYPING = Union[List[Fragment], List[float], List[str], List[tuple[float, str]]]
 
 

src/peptacular/glycan.py

@@ -134,8 +134,8 @@ def parse_glycan_formula(formula: str, sep: str = '') -> ChemComposition:
 
     try:
         return _parse_glycan_formula(formula, sep)
-    except InvalidGlycanFormulaError as e:
-        raise InvalidGlycanFormulaError(formula, e.msg) from e
+    except InvalidGlycanFormulaError as err:
+        raise InvalidGlycanFormulaError(formula, err.msg) from err
 
 
 def convert_glycan_formula_to_chem_formula(glycan: Union[ChemComposition, str]) -> str:

src/peptacular/isotope.py

@@ -243,10 +243,9 @@ def _convolve_distributions(dist1: Dict[float, float],
     if max_isotopes != sys.maxsize:
         sorted_result = sorted(result.items(), key=lambda x: x[1], reverse=True)
         # Retain only the top `max_isotopes` isotopes based on abundance
-        filtered_result = {mass: abundance for mass, abundance in sorted_result[:max_isotopes]}
-        return filtered_result
-    else:
-        return result
+        return dict(sorted_result[:max_isotopes])
+
+    return result
 
 
 def _calculate_elemental_distribution(element: str,
@@ -287,7 +286,7 @@ def _calculate_elemental_distribution(element: str,
     distribution = {0: 1.0}
     for _ in range(count):
         # Update the distribution by convolving it with the isotopes' distribution each time
-        isotope_distribution = {mass: abundance for mass, abundance in isotopes}
+        isotope_distribution = dict(isotopes)
         distribution = _convolve_distributions(distribution, isotope_distribution, None, min_abundance_threshold, None)
     return distribution
 

src/peptacular/mods/__init__.py

@@ -1,5 +1,9 @@
+"""
+Initialization file for the mods package.
+"""
+
 from . import mod_db
 from . import mod_db_setup
 
 from .mod_db import *
-from .mod_db_setup import *
+from .mod_db_setup import *

src/peptacular/mods/mod_db.py

@@ -54,8 +54,8 @@ def _get_comp(db: EntryDb, mod_str: str, orig_str: str) -> str:
     if mod_str.startswith('+') or mod_str.startswith('-'):
         try:
             _ = float(mod_str)
-        except ValueError:
-            raise InvalidDeltaMassError(orig_str)
+        except ValueError as err:
+            raise InvalidDeltaMassError(orig_str) from err
 
         raise DeltaMassCompositionError(orig_str)
 
@@ -71,8 +71,8 @@ def _get_comp(db: EntryDb, mod_str: str, orig_str: str) -> str:
         if comp is None:
             raise InvalidCompositionError(orig_str)
         return comp
-    else:
-        raise UnknownModificationError(orig_str)
+
+    raise UnknownModificationError(orig_str)
 
 
 def is_unimod_str(unimod_str: str) -> bool:
@@ -136,8 +136,7 @@ def _strip_unimod_str(unimod_str: str) -> str:
     unimod_str_lower = unimod_str.lower()
     if unimod_str_lower.startswith('unimod:') or unimod_str_lower.startswith('u:'):
         return unimod_str.split(':')[1]
-    else:
-        return unimod_str
+    return unimod_str
 
 
 def parse_unimod_mass(mod_str: str, monoisotopic: bool, precision: Optional[int] = None) -> float:
@@ -301,8 +300,7 @@ def _strip_psi_str(psi_str: str) -> str:
     psi_str_lower = psi_str.lower()
     if psi_str_lower.startswith('mod:') or psi_str_lower.startswith('m:') or psi_str_lower.startswith('psi-mod:'):
         return psi_str.split(':')[1]
-    else:
-        return psi_str
+    return psi_str
 
 
 def parse_psi_mass(mod_str: str, monoisotopic: bool, precision: Optional[int] = None) -> float:
@@ -433,8 +431,7 @@ def _strip_xlmod_str(xlmod_str: str) -> str:
     xlmod_str_lower = xlmod_str.lower()
     if xlmod_str_lower.startswith('xlmod:') or xlmod_str_lower.startswith('x:'):
         return xlmod_str.split(':')[1]
-    else:
-        return xlmod_str
+    return xlmod_str
 
 
 def parse_xlmod_mass(mod_str: str, monoisotopic: bool, precision: Optional[int] = None) -> float:
@@ -521,6 +518,9 @@ def parse_xlmod_comp(mod_str: str) -> str:
 
 
 def is_resid_str(resid_str: str) -> bool:
+    """
+    Check if a string is a RESID id or name.
+    """
     resid_str_lower = resid_str.lower()
     return resid_str_lower.startswith('resid:') or resid_str_lower.startswith('r:')
 
@@ -529,8 +529,7 @@ def _strip_resid_str(resid_str: str) -> str:
     resid_str_lower = resid_str.lower()
     if resid_str_lower.startswith('resid:') or resid_str_lower.startswith('r:'):
         return resid_str.split(':')[1]
-    else:
-        return resid_str
+    return resid_str
 
 
 def parse_resid_mass(mod_str: str, monoisotopic: bool, precision: Optional[int] = None) -> float:
@@ -654,8 +653,7 @@ def _strip_gno_str(gno_str: str) -> str:
     gno_str_lower = gno_str.lower()
     if gno_str_lower.startswith('gno:') or gno_str_lower.startswith('g:'):
         return gno_str.split(':')[1]
-    else:
-        return gno_str
+    return gno_str
 
 
 def parse_gno_mass(mod_str: str, monoisotopic: bool, precision: Optional[int] = None) -> float:

src/peptacular/mods/mod_db_setup.py

@@ -6,7 +6,7 @@
 import warnings
 from collections import Counter
 from functools import cached_property
-from typing import List, Dict, IO, Any, Union, Iterator
+from typing import List, Dict, IO, Any, Union, Iterator, Tuple
 
 from peptacular.constants import ISOTOPIC_ATOMIC_MASSES
 from peptacular.chem.chem_util import write_chem_formula, _parse_isotope_component, parse_chem_formula, chem_mass, \
@@ -639,8 +639,8 @@ def _get_xlmod_entries(terms: List[Dict[str, Any]]) -> List[ModEntry]:
             delta_formula = write_chem_formula(elem_counter)
 
             try:
-                delta_monoisotopic_mass_recalc = chem_mass(delta_formula, monoisotopic=True)
-                delta_average_mass_recalc = chem_mass(delta_formula, monoisotopic=False)
+                _ = chem_mass(delta_formula, monoisotopic=True)
+                _ = chem_mass(delta_formula, monoisotopic=False)
             except InvalidChemFormulaError as e:
                 warnings.warn(f'[{DbType.XLMOD}] Error parsing {term_id} {term_name} {delta_formula}, {e}')
                 delta_formula = None
@@ -710,8 +710,8 @@ def _get_gno_entries(terms: List[Dict[str, Any]]) -> List[ModEntry]:
             for symbol, count in tokens:
                 try:
                     comp = _glycan_comp(symbol)
-                except ValueError as e:
-                    warnings.warn(f'[{DbType.GNO}] Error parsing {term_id} {term_name} {val}, {e}')
+                except ValueError as err:
+                    warnings.warn(f'[{DbType.GNO}] Error parsing {term_id} {term_name} {val}, {err}')
                     composition = None
                     break
 
@@ -724,8 +724,8 @@ def _get_gno_entries(terms: List[Dict[str, Any]]) -> List[ModEntry]:
                 try:
                     delta_monoisotopic_mass_recalc = chem_mass(delta_formula, monoisotopic=True)
                     delta_average_mass_recalc = chem_mass(delta_formula, monoisotopic=False)
-                except InvalidChemFormulaError as e:
-                    warnings.warn(f'[{DbType.GNO}] Error parsing {term_id} {term_name} {delta_formula}, {e}')
+                except InvalidChemFormulaError as err:
+                    warnings.warn(f'[{DbType.GNO}] Error parsing {term_id} {term_name} {delta_formula}, {err}')
                     delta_formula = None
 
         if delta_monoisotopic_mass is not None:
@@ -1084,10 +1084,10 @@ def reload_from_file(self, file: str, use_synonyms: bool = False) -> None:
         try:
             self.reset()
             self.setup(entries, use_synonyms)
-        except Exception as e:
+        except Exception as err:
             self.id_map, self.name_map, self.synonym_map, self.mono_mass_map, self.avg_mass_map, self.use_synonyms, \
                 self.names_sorted, self.entries = old_maps
-            raise e
+            raise err
 
         # print(f'Reloaded {self.entry_type} database from {file}')
         # print('Entries:', len(self))
@@ -1098,10 +1098,11 @@ def _get_names_sorted(self) -> List[str]:
         return sorted(list(synonyms.union(names)), key=lambda x: len(x), reverse=True)
 
 
-def count_invalid_entries(entries: List[ModEntry]) -> (int, int, int):
-    none_mono = 0
-    none_avg = 0
-    none_comp = 0
+def count_invalid_entries(entries: List[ModEntry]) -> Tuple[int, int, int]:
+    """
+    Count the number of invalid entries in a list of ModEntry objects.
+    """
+    none_mono, none_avg, none_comp = 0, 0, 0
 
     for entry in entries:
         if entry.mono_mass is None:
@@ -1135,6 +1136,9 @@ def count_invalid_entries(entries: List[ModEntry]) -> (int, int, int):
 
 
 def reload_all_databases_from_online() -> None:
+    """
+    Reload all databases from the online sources
+    """
     MONOSACCHARIDES_DB.reload_from_online()
     UNIMOD_DB.reload_from_online()
     PSI_MOD_DB.reload_from_online()
@@ -1144,6 +1148,9 @@ def reload_all_databases_from_online() -> None:
 
 
 def reload_all_databases() -> None:
+    """
+    Reload all databases from the local files
+    """
     reset_all_databases()
     MONOSACCHARIDES_DB.reload_from_file(os.path.join(_obo_path, "monosaccharides_updated.obo"))
     UNIMOD_DB.reload_from_file(os.path.join(_obo_path, "unimod.obo"))
@@ -1154,6 +1161,9 @@ def reload_all_databases() -> None:
 
 
 def reset_all_databases() -> None:
+    """
+    Reset all databases to empty
+    """
     MONOSACCHARIDES_DB.reset()
     UNIMOD_DB.reset()
     PSI_MOD_DB.reset()

src/peptacular/proforma/__init__.py

@@ -1,10 +1,13 @@
+"""
+This module provides the main interface for the ProForma package.
+"""
+
 from . import proforma_dataclasses
 from . import proforma_parser
 from . import randomizer
 from . import input_convert
 
-
 from .proforma_dataclasses import *
 from .proforma_parser import *
 from .randomizer import *
-from .input_convert import *
+from .input_convert import *