stjames 0.0.64__tar.gz → 0.0.65__tar.gz

{stjames-0.0.64/stjames.egg-info → stjames-0.0.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: stjames
-Version: 0.0.64
+Version: 0.0.65
 Summary: standardized JSON atom/molecule encoding scheme
 Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/stjames

{stjames-0.0.64 → stjames-0.0.65}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stjames"
-version = "0.0.64"
+version = "0.0.65"
 description = "standardized JSON atom/molecule encoding scheme"
 readme = "README.md"
 requires-python = ">=3.11"

{stjames-0.0.64 → stjames-0.0.65}/stjames/atomium_stjames/mmcif.py

@@ -516,7 +516,7 @@ def add_atom_to_polymer(atom: dict[str, Any], aniso: dict[int, Any], model: dict
         try:
             model["polymer"][mol_id]["residues"][res_id] = {
                 "name": name,
-                "full_name": names.get(name),
+                "full_name": names.get(name).upper() if names.get(name) is not None else None,  # type: ignore [union-attr]
                 "atoms": {int(atom["id"]): atom_dict_to_atom_dict(atom, aniso)},
                 "number": len(model["polymer"][mol_id]["residues"]) + 1,
             }
@@ -530,7 +530,7 @@ def add_atom_to_polymer(atom: dict[str, Any], aniso: dict[int, Any], model: dict
                         "name": name,
                         "atoms": {int(atom["id"]): atom_dict_to_atom_dict(atom, aniso)},
                         "number": 1,
-                        "full_name": names.get(name),
+                        "full_name": names.get(name).upper() if names.get(name) is not None else None,  # type: ignore [union-attr]
                     }
                 },
             }
@@ -547,6 +547,8 @@ def add_atom_to_non_polymer(atom: dict[str, Any], aniso: dict[int, Any], model:
     :param names: lookup dictionary for full name information
     """
     mol_id = make_residue_id(atom)
+    if mol_type == "non-polymer":
+        mol_type = "non_polymer"
 
     try:
         model[mol_type][mol_id]["atoms"][int(atom["id"])] = atom_dict_to_atom_dict(atom, aniso)
@@ -554,7 +556,7 @@ def add_atom_to_non_polymer(atom: dict[str, Any], aniso: dict[int, Any], model:
         name = atom["auth_comp_id"]
         model[mol_type][mol_id] = {
             "name": name,
-            "full_name": names.get(name),
+            "full_name": names.get(name).upper() if names.get(name) is not None and names.get(name).lower() != "water" else None,  # type: ignore [union-attr]
             "internal_id": atom["label_asym_id"],
             "polymer": atom["auth_asym_id"],
             "atoms": {int(atom["id"]): atom_dict_to_atom_dict(atom, aniso)},
@@ -644,7 +646,7 @@ def atom_dict_to_atom_dict(d: dict[str, Any], aniso_dict: dict[int, Any]) -> dic
         "bvalue": d.get("B_iso_or_equiv"),
         "charge": d.get(charge, 0) if d.get(charge) != "?" else 0,
         "alt_loc": d.get("label_alt_id") if d.get("label_alt_id") != "." else None,
-        "anisotropy": aniso_dict.get(int(d["id"]), [0, 0, 0, 0, 0, 0]),
+        "anisotropy": aniso_dict.get(int(d["id"]), None),
         "is_hetatm": d.get("group_PDB", "ATOM") == "HETATM",
     }
 

{stjames-0.0.64 → stjames-0.0.65}/stjames/molecule.py

@@ -34,6 +34,7 @@ class VibrationalMode(Base):
     reduced_mass: Annotated[float, AfterValidator(round_float(3))]  # amu
     force_constant: Annotated[float, AfterValidator(round_float(3))]  # mDyne/Å
     displacements: Annotated[Vector3DPerAtom, AfterValidator(round_vector3d_per_atom(6))]  # Å
+    ir_intensity: Annotated[Optional[float], AfterValidator(round_optional_float(3))] = None  # km/mol
 
 
 class Molecule(Base):

{stjames-0.0.64 → stjames-0.0.65}/stjames/pdb.py

@@ -204,6 +204,12 @@ def fetch_pdb(code: str) -> PDB:
     return PDB.model_validate(astj.fetch(code, data_dict=True))
 
 
+def fetch_pdb_from_mmcif(code: str) -> PDB:
+    """Fetch a pdb from the Protein Data Bank."""
+    code += ".cif"
+    return PDB.model_validate(astj.fetch(code, data_dict=True))
+
+
 def pdb_from_pdb_filestring(pdb: str) -> PDB:
     """Read a PDB from a string."""
     return PDB.model_validate(pdb_dict_to_data_dict(pdb_string_to_pdb_dict(pdb)))

{stjames-0.0.64 → stjames-0.0.65}/stjames/workflows/__init__.py

@@ -12,6 +12,7 @@ from .docking import *
 from .electronic_properties import *
 from .fukui import *
 from .hydrogen_bond_basicity import *
+from .ion_mobility import *
 from .irc import *
 from .molecular_dynamics import *
 from .multistage_opt import *
@@ -34,6 +35,7 @@ WORKFLOW_NAME = Literal[
     "electronic_properties",
     "fukui",
     "hydrogen_bond_basicity",
+    "ion_mobility",
     "irc",
     "molecular_dynamics",
     "multistage_opt",
@@ -56,6 +58,7 @@ WORKFLOW_MAPPING: dict[WORKFLOW_NAME, Workflow] = {
     "electronic_properties": ElectronicPropertiesWorkflow,  # type: ignore [dict-item]
     "fukui": FukuiIndexWorkflow,  # type: ignore [dict-item]
     "hydrogen_bond_basicity": HydrogenBondBasicityWorkflow,  # type: ignore [dict-item]
+    "ion_mobility": IonMobilityWorkflow,  # type: ignore [dict-item]
     "irc": IRCWorkflow,  # type: ignore [dict-item]
     "molecular_dynamics": MolecularDynamicsWorkflow,  # type: ignore [dict-item]
     "multistage_opt": MultiStageOptWorkflow,  # type: ignore [dict-item]

stjames-0.0.65/stjames/workflows/admet.py

@@ -0,0 +1,39 @@
+"""ADME-Tox property prediction workflow."""
+
+import warnings
+from typing import Self
+
+from pydantic import model_validator
+
+from ..molecule import Molecule
+from .workflow import MoleculeWorkflow, SMILESWorkflow
+
+
+class ADMETWorkflow(SMILESWorkflow, MoleculeWorkflow):
+    """
+    A workflow for predicting ADME-Tox properties.
+
+    Inherited:
+    :param initial_smiles: SMILES string of molecule (mutually exclusive with initial_molecule)
+    :param initial_molecule: Molecule of interest (deprecated)
+    :param mode: Mode for workflow (currently unused)
+
+    New:
+    :param properties: predicted properties
+    """
+
+    initial_smiles: str = ""
+    initial_molecule: Molecule | None = None  # type: ignore [assignment]  # Deprecated
+    properties: dict[str, float | int] | None = None
+
+    @model_validator(mode="after")
+    def validate_mol_input(self) -> Self:
+        """Ensure that only one of initial_molecule or initial_smiles is set."""
+
+        if not (bool(self.initial_smiles) ^ bool(self.initial_molecule)):
+            raise ValueError("Can only set one of initial_molecule should and initial_smiles")
+
+        if self.initial_molecule is not None:
+            warnings.warn(DeprecationWarning("initial_molecule is deprecated. Use initial_smiles instead."))
+
+        return self

stjames-0.0.65/stjames/workflows/ion_mobility.py

@@ -0,0 +1,36 @@
+"""Ion mobility workflow."""
+
+from ..types import UUID
+from .workflow import MoleculeWorkflow
+
+
+class IonMobilityWorkflow(MoleculeWorkflow):
+    """
+    Workflow for calculating hydrogen bond basicity.
+
+    Inherited:
+    :param initial_molecule: Molecule of interest
+    :param mode: Mode for workflow (currently unused)
+
+    New:
+    :param do_csearch: whether to perform a conformational search
+    :param do_optimization: whether to perform an optimization
+
+    Results:
+    :param conformer_ccs: the collision cross section (Å**2) per conformer
+    :param conformer_ccs_stdev: the uncertainty in the same
+    :param conformer_weights: the Boltzmann weights at RT
+    :param average_ccs: the Boltzmann-weighted CCS for the ensemble
+    :param average_ccs_stdev: the uncertainty in the same
+    """
+
+    do_csearch: bool = True
+    do_optimization: bool = True
+    conformers: list[UUID] = []
+
+    conformer_ccs: list[float] = []
+    conformer_ccs_stdev: list[float] = []
+    boltzmann_weights: list[float] = []
+
+    average_ccs: float | None = None
+    average_ccs_stdev: float | None = None

stjames-0.0.65/stjames/workflows/macropka.py

@@ -0,0 +1,72 @@
+"""pKa workflow."""
+
+from typing import Annotated, Self
+
+from pydantic import AfterValidator, model_validator
+
+from ..base import Base, round_float
+from ..types import round_list
+from .workflow import SMILESWorkflow
+
+
+class MacropKaMicrostate(Base):
+    """
+    A microstate for pKa calculations.
+
+    :param smiles: SMILES string for this conformer
+    :param energy: free energy of this conformer
+    :param charge: the total charge
+    """
+
+    smiles: str
+    energy: Annotated[float, AfterValidator(round_float(3))]  # free energy
+    charge: int
+
+
+class MacropKaValue(Base):
+    """
+    Represents a change in pKa.
+
+    :param initial_charge: the charge of the initial state
+    :param final_charge: the charge of the final state
+    :param pKa: the pKa for the transition
+    """
+
+    initial_charge: int
+    final_charge: int
+    pKa: Annotated[float, AfterValidator(round_float(3))]
+
+
+class MacropKaWorkflow(SMILESWorkflow):
+    """
+    Workflow for calculating pKa.
+
+    Inherited:
+    :param initial_smiles:
+
+    New:
+    :param temperature: the temperature, in K
+    :param min_pH: for precomputed microstate weights
+    :param max_pH: for precomputed microstate weights
+
+    Results:
+    :param microstates: microstates
+    :param pKa_values: macroscopic pKa values
+    :param microstate_weights_by_pH: precompute the % of different microstates
+    """
+
+    temperature: Annotated[float, AfterValidator(round_float(3))] = 298.0
+    min_pH: Annotated[float, AfterValidator(round_float(3))] = 0.0
+    max_pH: Annotated[float, AfterValidator(round_float(3))] = 14.0
+
+    microstates: list[MacropKaMicrostate] = []
+    pKa_values: list[MacropKaValue] = []
+    microstate_weights_by_pH: dict[float, Annotated[list[float], AfterValidator(round_list(6))]] = {}
+
+    @model_validator(mode="after")
+    def check_weights(self) -> Self:
+        for weights in self.microstate_weights_by_pH.values():
+            if len(weights) != len(self.microstates):
+                raise ValueError("Length of microstate weights doesn't match!")
+
+        return self

{stjames-0.0.64 → stjames-0.0.65}/stjames/workflows/scan.py

@@ -4,7 +4,7 @@ from typing import Annotated
 
 import numpy as np
 from numpy.typing import NDArray
-from pydantic import AfterValidator
+from pydantic import AfterValidator, field_validator
 
 from ..base import Base, round_optional_float
 from ..molecule import Molecule
@@ -62,15 +62,33 @@ class ScanWorkflow(MoleculeWorkflow):
     :param mode: Mode for workflow (currently unused)
 
     New:
-    :param scan_settings: information about what coordinate to scan
+    :param scan_settings: what coordinate(s) to scan; if more than one, all will be performed simultaneously and should have the same number of steps
+    :param scan_settings_2d: what additional coordinate(s) to scan; makes a grid with `scan_settings`
+    :param wavefront propagation: whether to use wavefront propagation (10.1063/5.0009232) for more expensive but smoother scans
     :param calc_settings: settings for the calculation
     :param calc_engine: engine to use for the calculation
     :param scan_points: points along the scan
     """
 
-    scan_settings: ScanSettings
+    scan_settings: ScanSettings | list[ScanSettings]
+    scan_settings_2d: ScanSettings | list[ScanSettings] = []
     calc_settings: Settings
     calc_engine: str
 
+    wavefront_propagation: bool = True
+
     # UUIDs of scan points
     scan_points: list[UUID | None] = []
+
+    @field_validator("scan_settings", "scan_settings_2d", mode="after")
+    @classmethod
+    def validate_scan_settings(cls, val: ScanSettings | list[ScanSettings]) -> list[ScanSettings]:
+        """Ensure that scan_settings is a list, and that every list item has the same number of steps."""
+        if isinstance(val, ScanSettings):
+            val = [val]
+
+        for ss in val:
+            if ss.num != val[0].num:
+                raise ValueError("Concerted scan settings must have same number of steps!")
+
+        return val

{stjames-0.0.64 → stjames-0.0.65/stjames.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: stjames
-Version: 0.0.64
+Version: 0.0.65
 Summary: standardized JSON atom/molecule encoding scheme
 Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/stjames

{stjames-0.0.64 → stjames-0.0.65}/stjames.egg-info/SOURCES.txt

@@ -56,7 +56,9 @@ stjames/workflows/docking.py
 stjames/workflows/electronic_properties.py
 stjames/workflows/fukui.py
 stjames/workflows/hydrogen_bond_basicity.py
+stjames/workflows/ion_mobility.py
 stjames/workflows/irc.py
+stjames/workflows/macropka.py
 stjames/workflows/molecular_dynamics.py
 stjames/workflows/multistage_opt.py
 stjames/workflows/pka.py

{stjames-0.0.64 → stjames-0.0.65}/tests/test_pdb.py

@@ -1,6 +1,16 @@
 from pytest import mark
 
-from stjames.pdb import PDB, fetch_pdb, pdb_from_mmcif_filestring, pdb_from_pdb_filestring, pdb_object_to_pdb_filestring
+from stjames.pdb import (
+    PDB,
+    PDBDescription,
+    PDBExperiment,
+    PDBModel,
+    fetch_pdb,
+    fetch_pdb_from_mmcif,
+    pdb_from_mmcif_filestring,
+    pdb_from_pdb_filestring,
+    pdb_object_to_pdb_filestring,
+)
 
 
 def test_1ema() -> None:
@@ -8,6 +18,14 @@ def test_1ema() -> None:
     fetch_pdb("1EMA")
 
 
+def test_8qvy() -> None:
+    """
+    Human GABAA receptor
+    Not availble as a .pdb
+    """
+    fetch_pdb_from_mmcif("8VQY")
+
+
 def test_read_pdb_filestring() -> None:
     """Rest reading of a pdb string."""
     with open("tests/data/1ema.pdb") as f:
@@ -77,3 +95,46 @@ def test_from_pdb_to_pdb_1ema() -> None:
     pdb2 = pdb_from_pdb_filestring(filestring)
 
     assert pdb == pdb2
+
+def mmcif_author_format_to_pdb_format(authors: list[str]) -> list[str]:
+    return [f"{last.upper()}{first.upper()}" for first, last in
+            (author.split(", ") for author in authors)]
+
+def compare_descriptions_mmcif_and_pdb(mmcif_description: PDBDescription, pdb_description: PDBDescription) -> bool:
+    return (
+        mmcif_description.code == pdb_description.code and
+        mmcif_description.title == pdb_description.title and
+        mmcif_author_format_to_pdb_format(mmcif_description.authors) == (pdb_description.authors) and
+        mmcif_description.classification == pdb_description.classification and
+        mmcif_description.deposition_date == pdb_description.deposition_date and
+        sorted(mmcif_description.keywords) == sorted(pdb_description.keywords)
+    )
+
+def compare_experiments_mmcif_and_pdb(mmcif_experiment: PDBExperiment, pdb_experiment: PDBExperiment) -> bool:
+    return (
+        mmcif_experiment.expression_system.upper() == pdb_experiment.expression_system and  # type: ignore [union-attr]
+        mmcif_experiment.missing_residues == pdb_experiment.missing_residues and
+        mmcif_experiment.source_organism.upper() == pdb_experiment.source_organism and  # type: ignore [union-attr]
+        mmcif_experiment.technique == pdb_experiment.technique
+    )
+
+def compare_models_mmcif_and_pdb(mmcif_models: list[PDBModel], pdb_models: list[PDBModel]) -> bool:
+    for i in range(len(mmcif_models)):
+        assert mmcif_models[i].polymer == pdb_models[i].polymer
+        assert mmcif_models[i].non_polymer == pdb_models[i].non_polymer
+        assert mmcif_models[i].branched == pdb_models[i].branched
+    return True
+
+def test_from_mmcif_to_pdb_1ema() -> None:
+    with open("tests/data/1ema.cif") as f:
+        mmcif_data = f.read()
+
+    with open("tests/data/1ema.pdb") as f:
+        pdb_data = f.read()
+    mmcif_1ema = pdb_from_mmcif_filestring(mmcif_data)
+    pdb_1ema = pdb_from_pdb_filestring(pdb_data)
+
+    assert compare_descriptions_mmcif_and_pdb(mmcif_1ema.description, pdb_1ema.description)
+    assert compare_experiments_mmcif_and_pdb(mmcif_1ema.experiment, pdb_1ema.experiment)
+    assert mmcif_1ema.quality == pdb_1ema.quality
+    assert compare_models_mmcif_and_pdb(mmcif_1ema.models, pdb_1ema.models)

stjames-0.0.64/stjames/workflows/admet.py

@@ -1,18 +0,0 @@
-"""ADME-Tox property prediction workflow."""
-
-from .workflow import MoleculeWorkflow
-
-
-class ADMETWorkflow(MoleculeWorkflow):
-    """
-    A workflow for predicting ADME-Tox properties.
-
-    Inherited:
-    :param initial_molecule: Molecule of interest
-    :param mode: Mode for workflow (currently unused)
-
-    New:
-    :param properties: predicted properties
-    """
-
-    properties: dict[str, float | int] | None = None