stjames 0.0.104__tar.gz → 0.0.106__tar.gz

{stjames-0.0.104/stjames.egg-info → stjames-0.0.106}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stjames
-Version: 0.0.104
+Version: 0.0.106
 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.104 → stjames-0.0.106}/pyproject.toml

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

{stjames-0.0.104 → stjames-0.0.106}/stjames/method.py

@@ -135,3 +135,6 @@ PREPACKAGED_METHODS = [*XTB_METHODS, *COMPOSITE_METHODS, *PREPACKAGED_NNP_METHOD
 
 MethodWithCorrection = Literal[Method.WB97XD3, Method.WB97XV, Method.WB97MV, Method.WB97MD3BJ, Method.DSDBLYPD3BJ]
 METHODS_WITH_CORRECTION = [Method.WB97XD3, Method.WB97XV, Method.WB97MV, Method.WB97MD3BJ, Method.DSDBLYPD3BJ, Method.B97D3BJ]
+
+MGGAFunctionals = Literal[Method.R2SCAN, Method.R2SCAN3C, Method.TPSS, Method.TPSSH, Method.M06L, Method.M06, Method.M062X, Method.WB97MD3BJ, Method.WB97MV]
+MGGA_FUNCTIONALS = [Method.R2SCAN, Method.R2SCAN3C, Method.TPSS, Method.TPSSH, Method.M06L, Method.M06, Method.M062X, Method.WB97MD3BJ, Method.WB97MV]

{stjames-0.0.104 → stjames-0.0.106}/stjames/solvent.py

@@ -28,6 +28,8 @@ class Solvent(LowercaseStrEnum):
     ISOPROPANOL = "isopropanol"
     DIMETHYLACETAMIDE = "dimethylacetamide"
     DIMETHYLFORMAMIDE = "dimethylformamide"
+    N_METHYLPYRROLIDONE = "n_methylpyrrolidone"
+    ETHYLENE_GLYCOL = "ethylene_glycol"
 
 
 class SolventModel(LowercaseStrEnum):

{stjames-0.0.104 → stjames-0.0.106}/stjames/workflows/__init__.py

@@ -26,6 +26,7 @@ from .redox_potential import *
 from .scan import *
 from .solubility import *
 from .spin_states import *
+from .strain import *
 from .tautomer import *
 from .workflow import *
 
@@ -54,6 +55,7 @@ WORKFLOW_NAME = Literal[
     "scan",
     "solubility",
     "spin_states",
+    "strain",
     "tautomers",
 ]
 
@@ -82,5 +84,6 @@ WORKFLOW_MAPPING: dict[WORKFLOW_NAME, Workflow] = {
     "scan": ScanWorkflow,  # type: ignore [dict-item]
     "solubility": SolubilityWorkflow,  # type: ignore [dict-item]
     "spin_states": SpinStatesWorkflow,  # type: ignore [dict-item]
+    "strain": StrainWorkflow,  # type: ignore [dict-item]
     "tautomers": TautomerWorkflow,  # type: ignore [dict-item]
 }

{stjames-0.0.104 → stjames-0.0.106}/stjames/workflows/conformer_search.py

@@ -255,7 +255,41 @@ class iMTDsMTDSettings(iMTDSettings):
     run_type: str = "imtd-smtd"
 
 
-ConformerGenSettingsUnion = Annotated[ETKDGSettings | iMTDSettings, Field(discriminator="settings_type")]
+class LyrebirdSettings(ConformerGenSettings):
+    """
+    Settings for Lyrebird-based conformer generation.
+
+    Inherited:
+    :param mode: Mode for calculations
+    :param conf_opt_method: method for the optimization
+    :param screening: post-generation screening settings
+    :param constraints: constraints for conformer generation
+    :param nci: add a constraining potential for non-covalent interactions (not supported in ETKDG)
+    :param max_confs: maximum number of conformers to keep
+
+    New:
+    :param num_initial_confs: number of initial conformers to generate
+    """
+
+    num_initial_confs: int = 300
+    settings_type: Literal["lyrebird"] = "lyrebird"
+
+    @field_validator("constraints")
+    def check_constraints(cls, constraints: Sequence[Constraint]) -> Sequence[Constraint]:
+        if constraints:
+            raise ValueError("Lyrebird does not support constraints")
+
+        return tuple(constraints)
+
+    @field_validator("nci")
+    def check_nci(cls, nci: bool) -> bool:
+        if nci:
+            raise ValueError("Lyrebird does not support NCI")
+
+        return nci
+
+
+ConformerGenSettingsUnion = Annotated[ETKDGSettings | iMTDSettings | LyrebirdSettings, Field(discriminator="settings_type")]
 
 
 class ConformerGenMixin(BaseModel):

{stjames-0.0.104 → stjames-0.0.106}/stjames/workflows/docking.py

@@ -1,6 +1,6 @@
 """Docking workflow."""
 
-from typing import Annotated, Self
+from typing import Annotated, Self, TypeAlias
 
 from pydantic import AfterValidator, ConfigDict, field_validator, model_validator
 
@@ -10,18 +10,26 @@ from ..types import UUID, Vector3D
 from .conformer_search import ConformerGenSettingsUnion, ETKDGSettings
 from .workflow import MoleculeWorkflow
 
+ProteinUUID: TypeAlias = UUID
+CalculationUUID: TypeAlias = UUID
+
 
 class Score(Base):
     """
     Pose with its score.
 
-    :param pose: conformation of the ligand when docked
+    :param pose: conformation of the ligand when docked (calculation UUID)
+    :param complex_pdb: the UUID of the protein–ligand complex (protein UUID)
     :param score: score of the pose, in kcal/mol
+    :param posebusters_valid: whether or not the ligand pose passes the PoseBusters tests
+    :param strain: strain in kcal/mol
     """
 
-    pose: UUID | None  # for calculation
+    pose: CalculationUUID | None
+    complex_pdb: ProteinUUID | None
     score: Annotated[float, AfterValidator(round_float(3))]
     posebusters_valid: bool
+    strain: float | None
 
 
 class DockingSettings(Base):
@@ -78,17 +86,14 @@ class DockingWorkflow(MoleculeWorkflow):
     target_uuid: UUID | None = None
     pocket: tuple[Vector3D, Vector3D]
 
+    docking_settings: VinaSettings = VinaSettings()
+
     do_csearch: bool = True
     conformer_gen_settings: ConformerGenSettingsUnion = ETKDGSettings(mode="reckless")
-
     do_optimization: bool = True
-    # optimization_settings - here in future once we have a cleaner mode sol'n, ccw 7.9.25
-
-    docking_settings: VinaSettings = VinaSettings()
-
     do_pose_refinement: bool = True
 
-    conformers: list[UUID] = []
+    conformers: list[CalculationUUID] = []
     scores: list[Score] = []
 
     def __str__(self) -> str:

{stjames-0.0.104 → stjames-0.0.106}/stjames/workflows/nmr.py

@@ -9,7 +9,7 @@ from ..mode import Mode
 from ..settings import Settings
 from ..solvent import Solvent
 from ..types import UUID, round_list
-from .conformer_search import ConformerGenSettings, iMTDSettings
+from .conformer_search import ConformerGenSettingsUnion, iMTDSettings
 from .multistage_opt import MultiStageOptSettings
 from .workflow import MoleculeWorkflow
 
@@ -58,7 +58,7 @@ class NMRSpectroscopyWorkflow(MoleculeWorkflow):
     nmr_method: NMRMethod = NMRMethod.MAGNETZERO
     solvent: Solvent = Solvent.CHLOROFORM
 
-    conf_gen_settings: ConformerGenSettings | None = iMTDSettings(mode="careful")
+    conf_gen_settings: ConformerGenSettingsUnion | None = iMTDSettings(mode="careful")
     multistage_opt_settings: MultiStageOptSettings | None = MultiStageOptSettings(
         mode=Mode.MANUAL,
         optimization_settings=[Settings(method="aimnet2_wb97md3", tasks=["optimize"])],

stjames-0.0.106/stjames/workflows/pka.py

@@ -0,0 +1,115 @@
+"""pKa workflow."""
+
+from typing import Annotated, Optional, Self
+
+from pydantic import AfterValidator, model_validator
+
+from ..base import Base, LowercaseStrEnum, round_float, round_optional_float
+from ..mode import Mode
+from ..solvent import Solvent
+from .workflow import DBCalculation, MoleculeWorkflow, SMILESWorkflow
+
+CHEMPROP_NEVOLIANUS2025_ALLOWED_SOLVENTS = {
+    Solvent.WATER,
+    Solvent.DIMETHYLSULFOXIDE,
+    Solvent.DIMETHYLFORMAMIDE,
+    Solvent.ACETONITRILE,
+    Solvent.METHANOL,
+    Solvent.ETHANOL,
+    Solvent.ETHYLENE_GLYCOL,
+    Solvent.N_METHYLPYRROLIDONE,
+}
+
+
+class MicroscopicpKaMethod(LowercaseStrEnum):
+    AIMNET2_WAGEN2024 = "aimnet2_wagen2024"
+    CHEMPROP_NEVOLIANUS2025 = "chemprop_nevolianus2025"
+
+
+class pKaMicrostate(Base):
+    """
+    A microstate for pKa calculations.
+
+    :param atom_index: index of the atom
+    :param smiles: SMILES of the microstate
+    :param structures: DBCalculation for the microstate
+    :param deltaG: relative free energy
+    :param pka: pKa
+    :uncertainty: uncertainty
+    """
+
+    atom_index: int
+    smiles: Optional[str]
+    structures: list[DBCalculation] = []
+    deltaG: Annotated[Optional[float], AfterValidator(round_optional_float(3))] = None
+    pka: Annotated[float, AfterValidator(round_float(3))]
+    uncertainty: Annotated[Optional[float], AfterValidator(round_optional_float(3))] = None
+
+
+class pKaWorkflow(SMILESWorkflow, MoleculeWorkflow):
+    """
+    Workflow for calculating pKa.
+
+    Inherited:
+    :param initial_molecule: Molecule of interest
+    :param mode: Mode for workflow
+    :param initial_smiles: SMILES of the molecule of interest
+
+    New:
+    :param microscopic_pka_method: method used for pka prediciton
+    :param solvent: solvent for the pka prediction
+    :param pka_range: range of pKa values to consider
+    :param deprotonate_elements: elements to deprotonate
+    :param deprotonate_atoms: atoms to deprotonate
+    :param protonate_elements: elements to protonate
+    :param protonate_atoms: atom indices to protonate
+    :param reasonableness_buffer: buffer for pKa reasonableness
+
+    Results:
+    :param structures: DBCalculations for the microstates
+    :param conjugate_acids: conjugate acid microstates
+    :param conjugate_bases: conjugate base microstates
+    :param strongest_acid: pKa of the strongest acid
+    :param strongest_base: pKa of the strongest base
+    """
+
+    mode: Mode = Mode.CAREFUL
+
+    microscopic_pka_method: MicroscopicpKaMethod = MicroscopicpKaMethod.CHEMPROP_NEVOLIANUS2025
+    solvent: Solvent = Solvent.WATER
+    pka_range: tuple[float, float] = (2, 12)
+    deprotonate_elements: list[int] = [7, 8, 16]
+    deprotonate_atoms: list[int] = []
+    protonate_elements: list[int] = [7]
+    protonate_atoms: list[int] = []
+
+    reasonableness_buffer: float = 5
+
+    structures: list[DBCalculation] = []
+    conjugate_acids: list[pKaMicrostate] = []
+    conjugate_bases: list[pKaMicrostate] = []
+    strongest_acid: Annotated[float | None, AfterValidator(round_optional_float(3))] = None
+    strongest_base: Annotated[float | None, AfterValidator(round_optional_float(3))] = None
+
+    @model_validator(mode="after")
+    def check_method_settings(self) -> Self:
+        """Check that models with limited domain of applicability are predicting within correct domain."""
+        match self.microscopic_pka_method:
+            case MicroscopicpKaMethod.AIMNET2_WAGEN2024:
+                if self.solvent is not Solvent.WATER:
+                    raise ValueError(f"{self.microscopic_pka_method} only supports water")
+            case MicroscopicpKaMethod.CHEMPROP_NEVOLIANUS2025:
+                if self.solvent not in CHEMPROP_NEVOLIANUS2025_ALLOWED_SOLVENTS:
+                    raise ValueError(f"Solvent `{self.solvent}` is not supported by method `{self.microscopic_pka_method}`.")
+                if len(self.protonate_atoms) or len(self.deprotonate_atoms):
+                    raise ValueError(f"Method `{self.microscopic_pka_method}` does not support selecting atoms by number.")
+        return self
+
+    @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")
+
+        return self

{stjames-0.0.104 → stjames-0.0.106}/stjames/workflows/protein_cofolding.py

@@ -1,13 +1,16 @@
-"""Protein Cofolding Workflow."""
+"""Protein cofolding Workflow."""
 
-from typing import Annotated, Literal
+from typing import Annotated, Literal, TypeAlias
 
 from pydantic import AfterValidator, BaseModel, ConfigDict
 
-from ..base import LowercaseStrEnum, round_float
+from ..base import LowercaseStrEnum, round_float, round_optional_float
 from ..types import UUID, round_list
 from .workflow import FASTAWorkflow
 
+ProteinUUID: TypeAlias = UUID
+CalculationUUID: TypeAlias = UUID
+
 
 class CofoldingModel(LowercaseStrEnum):
     """Cofolding model to be used for prediction."""
@@ -45,6 +48,8 @@ class PocketConstraint(BaseModel):
 
 
 class CofoldingScores(BaseModel):
+    """The output scores from co-folding scores."""
+
     confidence_score: Annotated[float, AfterValidator(round_float(3))]
     ptm: Annotated[float, AfterValidator(round_float(3))]  # predicted template modeling score
     iptm: Annotated[float, AfterValidator(round_float(3))]  # interface predicted template modeling score
@@ -71,7 +76,17 @@ class ProteinCofoldingWorkflow(FASTAWorkflow):
     New:
     :param use_msa_server: whether to use the MSA server
     :param use_templates_server: whether to use the templates server
+    :param use_potentials: whether to use the potentials (inference-time steering) with Boltz
+    :param contact_constraints: Boltz contact constraints
+    :param pocket_constraints: Boltz pocket constraints
+    :param do_pose_refinement: whether to optimize non-rotatable bonds in output poses
+    :param compute_strain: whether to compute the strain of the pose (if `pose_refinement` is enabled)
+    :param model: which cofolding model to use
+    :param affinity_score: the affinity score
+    :param lddt: the local distance different test result
     :param predicted_structure_uuid: UUID of the predicted structure
+    :param scores: the output cofolding scores
+    :param pose: the UUID of the calculation pose
     """
 
     model_config = ConfigDict(validate_assignment=True)
@@ -81,9 +96,15 @@ class ProteinCofoldingWorkflow(FASTAWorkflow):
     use_potentials: bool = False
     contact_constraints: list[ContactConstraint] = []
     pocket_constraints: list[PocketConstraint] = []
+    do_pose_refinement: bool = False
+    compute_strain: bool = False
 
-    predicted_structure_uuid: UUID | None = None
-    scores: CofoldingScores | None = None
     model: CofoldingModel = CofoldingModel.BOLTZ_2
     affinity_score: AffinityScore | None = None
     lddt: Annotated[list[float] | None, AfterValidator(round_list(3))] = None
+
+    predicted_structure_uuid: ProteinUUID | None = None
+    scores: CofoldingScores | None = None
+    pose: CalculationUUID | None = None
+    posebusters_valid: bool | None = None
+    strain: Annotated[float | None, AfterValidator(round_optional_float(3))] = None

{stjames-0.0.104 → stjames-0.0.106}/stjames/workflows/solubility.py

@@ -41,6 +41,7 @@ class SolubilityWorkflow(SMILESWorkflow):
 
     Inputs:
     :param initial_smiles: SMILES string of the molecule
+    :param solubility_method: model used for solubility prediction
     :param solvents: list of solvent SMILES strings
     :param temperatures: temperatures in K
 
@@ -48,8 +49,8 @@ class SolubilityWorkflow(SMILESWorkflow):
     :param solubilities: {solvent: SolubilityResult}
     """
 
-    solubility_method: SolubilityMethod = SolubilityMethod.FASTSOLV
     initial_smiles: str
+    solubility_method: SolubilityMethod = SolubilityMethod.FASTSOLV
     solvents: list[str] = ["O"]
     temperatures: list[float] = [298.15]
 

stjames-0.0.106/stjames/workflows/strain.py

@@ -0,0 +1,46 @@
+from typing import Annotated
+
+from pydantic import AfterValidator
+
+from ..base import round_float, round_optional_float
+from ..mode import Mode
+from ..settings import Settings
+from ..types import UUID
+from .conformer_search import ConformerGenSettingsUnion, ETKDGSettings
+from .multistage_opt import MultiStageOptSettings
+from .workflow import MoleculeWorkflow
+
+
+class StrainWorkflow(MoleculeWorkflow):
+    """
+    Workflow for calculating the strain of a given molecular geometry.
+
+    Inherited:
+    :param initial_molecule: Molecule of interest
+    :param mode: Mode for workflow (currently unused)
+
+    New:
+    :param conf_gen_settings : the conformer-search settings.
+    :param multistage_opt_settings: the optimization settings.
+    :param harmonic_constraint_spring_constant: the spring constant for the constraints in kcal/mol/Å
+    :param constrain_hydrogens: whether or not to constrain hydrogens
+
+    Results:
+    :param conformers: list of conformer UUIDs
+    :param constrained_optimization: the UUID of the optimized strained structure
+    :param strain: the actual strain in kcal/mol
+    """
+
+    conf_gen_settings: ConformerGenSettingsUnion = ETKDGSettings(mode="rapid")
+    multistage_opt_settings: MultiStageOptSettings = MultiStageOptSettings(
+        mode=Mode.MANUAL,
+        optimization_settings=[Settings(method="aimnet2_wb97md3", tasks=["optimize"])],
+        singlepoint_settings=Settings(method="aimnet2_wb97md3", tasks=["energy"], solvent_settings={"solvent": "water", "model": "cpcmx"}),
+    )
+
+    harmonic_constraint_spring_constant: Annotated[float, AfterValidator(round_float(3))] = 5.0
+    constrain_hydrogens: bool = False
+
+    constrained_optimization: UUID | None = None
+    conformers: list[UUID | None] = []
+    strain: Annotated[float | None, AfterValidator(round_optional_float(3))] = None

{stjames-0.0.104 → stjames-0.0.106/stjames.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stjames
-Version: 0.0.104
+Version: 0.0.106
 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.104 → stjames-0.0.106}/stjames.egg-info/SOURCES.txt

@@ -70,6 +70,7 @@ stjames/workflows/redox_potential.py
 stjames/workflows/scan.py
 stjames/workflows/solubility.py
 stjames/workflows/spin_states.py
+stjames/workflows/strain.py
 stjames/workflows/tautomer.py
 stjames/workflows/workflow.py
 tests/test_constraints.py

stjames-0.0.104/stjames/workflows/pka.py

@@ -1,66 +0,0 @@
-"""pKa workflow."""
-
-from typing import Annotated
-
-from pydantic import AfterValidator
-
-from ..base import Base, round_float, round_optional_float
-from ..mode import Mode
-from .workflow import DBCalculation, MoleculeWorkflow
-
-
-class pKaMicrostate(Base):
-    """
-    A microstate for pKa calculations.
-
-    :param atom_index: index of the atom
-    :param structures: DBCalculation for the microstate
-    :param deltaG: relative free energy
-    :param pka: pKa
-    """
-
-    atom_index: int
-    structures: list[DBCalculation] = []
-    deltaG: Annotated[float, AfterValidator(round_float(3))]
-    pka: Annotated[float, AfterValidator(round_float(3))]
-
-
-class pKaWorkflow(MoleculeWorkflow):
-    """
-    Workflow for calculating pKa.
-
-    Inherited:
-    :param initial_molecule: Molecule of interest
-    :param mode: Mode for workflow
-
-    New:
-    :param pka_range: range of pKa values to consider
-    :param deprotonate_elements: elements to deprotonate
-    :param deprotonate_atoms: atoms to deprotonate
-    :param protonate_elements: elements to protonate
-    :param protonate_atoms: atom indices to protonate
-    :param reasonableness_buffer: buffer for pKa reasonableness
-
-    Results:
-    :param structures: DBCalculations for the microstates
-    :param conjugate_acids: conjugate acid microstates
-    :param conjugate_bases: conjugate base microstates
-    :param strongest_acid: pKa of the strongest acid
-    :param strongest_base: pKa of the strongest base
-    """
-
-    mode: Mode = Mode.CAREFUL
-
-    pka_range: tuple[float, float] = (2, 12)
-    deprotonate_elements: list[int] = [7, 8, 16]
-    deprotonate_atoms: list[int] = []
-    protonate_elements: list[int] = [7]
-    protonate_atoms: list[int] = []
-
-    reasonableness_buffer: float = 5
-
-    structures: list[DBCalculation] = []
-    conjugate_acids: list[pKaMicrostate] = []
-    conjugate_bases: list[pKaMicrostate] = []
-    strongest_acid: Annotated[float | None, AfterValidator(round_optional_float(3))] = None
-    strongest_base: Annotated[float | None, AfterValidator(round_optional_float(3))] = None