helmkit 0.7.5__tar.gz → 0.7.7__tar.gz

{helmkit-0.7.5 → helmkit-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: helmkit
-Version: 0.7.5
+Version: 0.7.7
 Summary: Parse HELM strings into RDKit molecules
 License-File: LICENSE
 Requires-Python: >=3.11

{helmkit-0.7.5 → helmkit-0.7.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "helmkit"
-version = "0.7.5"
+version = "0.7.7"
 description = "Parse HELM strings into RDKit molecules"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -47,6 +47,11 @@ ignore = ["I001", "N999"]
 [tool.ruff.format]
 skip-magic-trailing-comma = true
 
+[tool.ty.rules]
+all = "error"
+unsound-return-statement = "ignore"
+unsound-assignment = "ignore"
+
 [tool.ty.src]
 include = ["src"]
 exclude = ["tests"]

helmkit-0.7.7/src/helmkit/__init__.py

@@ -0,0 +1,6 @@
+from .molecule import load_in_parallel
+from .molecule import load_monomer_library
+from .molecule import MAX_RGROUPS
+from .molecule import Molecule
+
+__all__ = ["MAX_RGROUPS", "Molecule", "load_in_parallel", "load_monomer_library"]

{helmkit-0.7.5 → helmkit-0.7.7}/src/helmkit/molecule.py

@@ -4,9 +4,13 @@ import re
 import warnings
 from collections import defaultdict
 from collections.abc import Callable
+from collections.abc import Iterable
 from collections.abc import Sequence
 from functools import lru_cache
 from importlib.resources import files
+from typing import assert_never
+from typing import cast
+from typing import Literal
 from typing import overload
 from typing import TypedDict
 from typing import TypeVar
@@ -15,16 +19,13 @@ from rdkit import Chem
 from rdkit import rdBase
 
 
-class SequenceConstants:
-    max_rgroups: int = 4
+MAX_RGROUPS = 4
 
 
 def get_molecule_property(
     molecule: Chem.Mol, property_name: str, default: str | None = None
 ) -> str | None:
-    return (
-        molecule.GetProp(property_name) if molecule.HasProp(property_name) else default
-    )
+    return molecule.GetProp(property_name, default=default)
 
 
 T = TypeVar("T")
@@ -69,14 +70,14 @@ def infer_attachment_points(
             continue
 
         atom = molecule.GetAtomWithIdx(r_idx)
+        bonds: tuple[Chem.Bond, ...] = atom.GetBonds()
 
-        for bond in atom.GetBonds():
+        for bond in bonds:
             other_idx = bond.GetOtherAtomIdx(r_idx)
             attachment_points.append(other_idx)
             break
         else:
-            attachment_points.append(None)
-            warnings.warn(
+            raise ValueError(
                 f"R-group atom {r_idx} has no bonds to determine attachment point"
             )
 
@@ -103,12 +104,13 @@ def load_monomer_library(library_path: str | None = None) -> MonomerLibrary:
     monomers_dict: MonomerLibrary = defaultdict(dict)
     supplier = Chem.SDMolSupplier(library_path, removeHs=False)
 
-    for mol in supplier:
+    for mol in cast(Iterable[Chem.Mol | None], supplier):
         if mol is None:
             continue
 
         symbol = get_molecule_property(mol, "symbol")
         if not symbol:
+            warnings.warn("Monomer without a symbol property will be skipped")
             continue
 
         m_type = get_molecule_property(mol, "m_type", "")
@@ -122,9 +124,9 @@ def load_monomer_library(library_path: str | None = None) -> MonomerLibrary:
         rgroup_idx = parse_comma_separated_property(mol, "m_RgroupIdx", int)
         attachment_point_idx = infer_attachment_points(mol, rgroup_idx)
 
-        abbr = get_molecule_property(mol, "m_abbr", "")
-        if not abbr:
-            continue
+        # m_abbr is only used for display, so fall back to the symbol when a
+        # library does not provide it instead of dropping the monomer.
+        abbr = get_molecule_property(mol, "m_abbr") or symbol
 
         monomers_dict[m_type][symbol] = {
             "m_romol": mol,
@@ -183,13 +185,13 @@ def _create_missing_monomer(monomer_name: str, m_type: str = "aa") -> MonomerDat
     r_group_idx = [idx for _, idx in sorted_r]
     mol = Chem.RenumberAtoms(mol, main_atoms + r_group_idx)
 
-    rgroup_idx_full: list[int | None] = [None] * SequenceConstants.max_rgroups
+    rgroup_idx_full: list[int | None] = [None] * MAX_RGROUPS
     for i, (r_num, _) in enumerate(sorted_r):
-        if 1 <= r_num <= SequenceConstants.max_rgroups:
+        if 1 <= r_num <= MAX_RGROUPS:
             rgroup_idx_full[r_num - 1] = len(main_atoms) + i
 
     attachment_points = infer_attachment_points(mol, rgroup_idx_full)
-    rgroup_vals: list[str | None] = [None] * SequenceConstants.max_rgroups
+    rgroup_vals: list[str | None] = [None] * MAX_RGROUPS
 
     if m_type == "aa" and "_R1" not in monomer_name:
         matches = {
@@ -295,10 +297,10 @@ class Molecule:
     def _split_helm_sections(
         self, helm: str
     ) -> tuple[list[str], list[str], list[str], str, str]:
-        parts = self._dollar_outside_brackets.split(helm, 4)
+        parts: list[str] = self._dollar_outside_brackets.split(helm, 4)
         parts.extend([""] * (5 - len(parts)))
 
-        polymers = (
+        polymers: list[str] = (
             self._pipe_outside_brackets.split(parts[0])
             if "|" in parts[0]
             else [parts[0]]
@@ -333,17 +335,18 @@ class Molecule:
 
         return result
 
-    def _extract_chain_id(self, chain_str: str) -> tuple[str, str]:
+    @staticmethod
+    def _extract_polymer_type(chain_str: str) -> Literal["PEPTIDE", "RNA", "CHEM"]:
         """Extract chain ID and return (chain_id, polymer_type)."""
         match = re.fullmatch(r"([A-Z]+)(\d+)", chain_str)
         if not match:
             raise ValueError(f"Invalid chain format: {chain_str}")
 
-        polymer_type = match.group(1)
+        polymer_type: str = match.group(1)
         if polymer_type not in {"PEPTIDE", "RNA", "CHEM"}:
             raise ValueError(f"Unsupported polymer type: {polymer_type}")
 
-        return chain_str, polymer_type
+        return polymer_type
 
     def _process_monomer(
         self, monomer_name: str, chain_id: str, residue_idx: int, polymer_type: str
@@ -354,7 +357,7 @@ class Molecule:
             if monomer_name.startswith("[") and monomer_name.endswith("]")
             else monomer_name
         )
-        if monomer_name == "":
+        if not monomer_name:
             raise ValueError(f"Monomer {residue_idx + 1} has no name. Check HELM.")
 
         # Check for (a,[b]) pattern
@@ -427,8 +430,8 @@ class Molecule:
                 warnings.warn(f"No sequence in polymer: {chain}")
                 continue
 
-            id_chain = chain[: match.start()]
-            chain_id, polymer_type = self._extract_chain_id(id_chain)
+            chain_id = chain[: match.start()]
+            polymer_type = self._extract_polymer_type(chain_id)
 
             if chain_id in self.chain_offset:
                 raise ValueError(f"Duplicate chain ID: {chain_id}")
@@ -446,8 +449,6 @@ class Molecule:
                     monomer = self._process_monomer(
                         monomer_name, chain_id, residue_idx, polymer_type
                     )
-                    if not monomer:
-                        continue
 
                     self.monomers.append(monomer)
                     self.residue_reps[chain_id].append(monomer_idx)
@@ -551,9 +552,12 @@ class Molecule:
                 self.monomers.append(monomer)
                 self.residue_reps[chain_id].append(monomer_idx)
                 monomer_idx += 1
+            else:
+                assert_never(polymer_type)
 
+    @staticmethod
     def _parse_connection(
-        self, connection_str: str
+        connection_str: str,
     ) -> tuple[str, int, int, str, int, int] | None:
         """Parse a single connection string."""
         parts = connection_str.split(",")
@@ -660,9 +664,9 @@ class Molecule:
 
         rgroups = monomer["m_Rgroups"]
         rgroup_idx = monomer["m_RgroupIdx"]
-        for i in range(min(len(rgroups), SequenceConstants.max_rgroups)):
+        for i in range(min(len(rgroups), MAX_RGROUPS)):
             if rgroups[i] is not None:
-                self._replace_rgroup(self._mol, 0, rgroup_idx[i], rgroups[i])
+                self._replace_rgroup(0, rgroup_idx[i], rgroups[i])
 
         current_offset = self._mol.GetNumAtoms()
         self.offset = [0, current_offset]
@@ -672,11 +676,9 @@ class Molecule:
 
             rgroups = monomer["m_Rgroups"]
             rgroup_idx = monomer["m_RgroupIdx"]
-            for i in range(min(len(rgroups), SequenceConstants.max_rgroups)):
+            for i in range(min(len(rgroups), MAX_RGROUPS)):
                 if rgroups[i] is not None:
-                    self._replace_rgroup(
-                        self._mol, current_offset, rgroup_idx[i], rgroups[i]
-                    )
+                    self._replace_rgroup(current_offset, rgroup_idx[i], rgroups[i])
 
             atom_count = monomer["m_romol"].GetNumAtoms()
             current_offset += atom_count
@@ -695,10 +697,9 @@ class Molecule:
                 absolute_atom1_idx, absolute_atom2_idx, Chem.BondType.SINGLE
             )
 
-    def _replace_rgroup(
-        self, rdkit_mol: Chem.RWMol, atom_offset: int, atom_idx: int, atom_type: str
-    ) -> None:
+    def _replace_rgroup(self, atom_offset: int, atom_idx: int, atom_type: str) -> None:
         """Replace an R-group with the appropriate atom type."""
+        rdkit_mol = self.mol
         absolute_idx = atom_offset + atom_idx
 
         if atom_type == "OH":