helmkit 0.7.6__tar.gz → 0.7.7__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "helmkit"
-version = "0.7.6"
+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.6 → 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
@@ -21,9 +25,7 @@ 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")
@@ -68,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"
             )
 
@@ -102,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", "")
@@ -121,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,
@@ -294,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]]
@@ -332,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
@@ -353,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
@@ -426,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}")
@@ -445,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)
@@ -550,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(",")
@@ -661,7 +666,7 @@ class Molecule:
         rgroup_idx = monomer["m_RgroupIdx"]
         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]
@@ -673,9 +678,7 @@ class Molecule:
             rgroup_idx = monomer["m_RgroupIdx"]
             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
@@ -694,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":