rowan-python 3.1.4__py3-none-any.whl → 3.1.6__py3-none-any.whl

rowan/__init__.py

@@ -2,15 +2,21 @@
 from . import constants
 from stjames import (
     Atom,
+    BandStructure,
     BindingPoseContact,
+    HydrationBridgeResidue,
+    HydrationSite,
     ConformerGenSettings,
     Constraint,
     ConstraintType,
     ConformerClusteringSettings,
     ConformerGenSettingsUnion,
     Correction,
+    CovalentInhibitorScanSettings,
+    DockingSettings,
     Engine,
     ETKDGSettings,
+    GninaSettings,
     GreedyClusteringSettings,
     iMTDSettings,
     KMeansClusteringSettings,
@@ -27,8 +33,10 @@ from stjames import (
     Settings,
     Solvent,
     SolventSettings,
+    SinglePointEnergySettings,
     Task,
     VibrationalMode,
+    VinaSettings,
 )
 from stjames.workflows.relative_binding_free_energy_perturbation import RBFEGraph, RBFEGraphEdge
 from stjames.excited_state_settings import TDDFTSettings
@@ -40,11 +48,9 @@ from stjames.engine_compatibility import (
     METHOD_ENGINES,
     get_supported_corrections,
 )
-from stjames.optimization.freezing_string_method import (
-    FSMInterpolation,
-    FSMOptimizationCoordinates,
-    FSMSettings,
-)
+from stjames.optimization.band_method import NEBSettings
+from stjames.optimization.interpolation import Interpolation
+from stjames.optimization.string_method import FSMSettings, StringMethodSettings
 
 api_key: str | None = None
 project_uuid: str | None = None

rowan/molecule.py

@@ -237,6 +237,50 @@ class Molecule(BaseModel):
         """Nuclear gradient (Hartree/Bohr)."""
         return self._stjames.gradient
 
+    @property
+    def symmetry(self) -> str | int | None:
+        """Space group number (1–230) or point group symbol."""
+        return self._stjames.symmetry
+
+    @property
+    def xrd_peaks(self) -> list[tuple[int, int, int, float]] | None:
+        """XRD reflections as (h, k, l, intensity) tuples."""
+        return self._stjames.x_ray_diffraction_peaks
+
+    @property
+    def band_structure(self) -> "stjames.BandStructure | None":
+        """Electronic band structure and DOS (periodic systems only)."""
+        return self._stjames.band_structure
+
+    @property
+    def band_gap(self) -> float | None:
+        """Band gap (Hartree)."""
+        bs = self._stjames.band_structure
+        return bs.band_gap if bs is not None else None
+
+    @property
+    def density_of_states(self) -> list[tuple[float, float]] | None:
+        """Total DOS as (energy in Hartree, k-weighted count) pairs (Fermi level = 0)."""
+        bs = self._stjames.band_structure
+        return bs.total_density_of_states if bs is not None else None
+
+    @property
+    def elastic_tensor(
+        self,
+    ) -> (
+        tuple[
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+        ]
+        | None
+    ):
+        """Elastic stiffness matrix in GPa (Voigt order: xx yy zz yz xz xy)."""
+        return self._stjames.elastic_tensor
+
     # -- Geometric utilities --
 
     def distance(self, i: int, j: int) -> float:

rowan/workflows/__init__.py

@@ -47,7 +47,17 @@ from .bde import (
     find_cx_bonds,
     submit_bde_workflow,
 )
+from .binding_affinity import (
+    BindingAffinityResult,
+    BindingAffinityScore,
+    submit_binding_affinity_workflow,
+)
 from .conformer_search import ConformerSearchResult, submit_conformer_search_workflow
+from .covalent_inhibitor_scan import (
+    CovalentInhibitorScanPoint,
+    CovalentInhibitorScanResult,
+    submit_covalent_inhibitor_scan_workflow,
+)
 from .descriptors import DescriptorsResult, submit_descriptors_workflow
 from .docking import DockingResult, DockingScore, submit_docking_workflow
 from .double_ended_ts_search import (

rowan/workflows/analogue_docking.py

@@ -59,6 +59,7 @@ class AnalogueDockingResult(WorkflowResult):
                     posebusters_valid=s.posebusters_valid,
                     strain=s.strain,
                     rmsd=s.rmsd,
+                    mmgbsa_score=s.mmgbsa_score,
                 )
                 for s in scores
             ]

rowan/workflows/basic_calculation.py

@@ -136,6 +136,54 @@ class BasicCalculationResult(WorkflowResult):
         mol = self.molecule
         return mol.frequencies if mol else None
 
+    @property
+    def symmetry(self) -> str | int | None:
+        """Space group number (1–230) or point group symbol."""
+        mol = self.molecule
+        return mol.symmetry if mol else None
+
+    @property
+    def xrd_peaks(self) -> list[tuple[int, int, int, float]] | None:
+        """XRD reflections as (h, k, l, intensity) tuples."""
+        mol = self.molecule
+        return mol.xrd_peaks if mol else None
+
+    @property
+    def band_structure(self) -> stjames.BandStructure | None:
+        """Electronic band structure and DOS (periodic systems only)."""
+        mol = self.molecule
+        return mol.band_structure if mol else None
+
+    @property
+    def band_gap(self) -> float | None:
+        """Band gap (Hartree)."""
+        mol = self.molecule
+        return mol.band_gap if mol else None
+
+    @property
+    def density_of_states(self) -> list[tuple[float, float]] | None:
+        """Total DOS as (energy in Hartree, k-weighted count) pairs (Fermi level = 0)."""
+        mol = self.molecule
+        return mol.density_of_states if mol else None
+
+    @property
+    def elastic_tensor(
+        self,
+    ) -> (
+        tuple[
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+            tuple[float, float, float, float, float, float],
+        ]
+        | None
+    ):
+        """Elastic stiffness matrix in GPa (Voigt order: xx yy zz yz xz xy)."""
+        mol = self.molecule
+        return mol.elastic_tensor if mol else None
+
 
 def settings_from_preset(preset: PresetName, **overrides: Any) -> stjames.Settings:
     """

rowan/workflows/binding_affinity.py

@@ -0,0 +1,140 @@
+"""Binding affinity workflow — SQM-based scoring of protein–ligand complexes."""
+
+from dataclasses import dataclass
+
+import stjames
+from stjames import SinglePointEnergySettings
+
+from ..folder import Folder
+from ..protein import Protein
+from ..types import StructureInput
+from ..utils import api_client
+from .base import (
+    Message,
+    Workflow,
+    WorkflowResult,
+    molecule_to_dict,
+    parse_messages,
+    register_result,
+    require_coordinates,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class BindingAffinityScore:
+    """
+    Binding affinity score for a single pose.
+
+    :param binding_affinity: binding affinity in kcal/mol
+    :param strain: strain energy in kcal/mol, or None if not computed
+    """
+
+    binding_affinity: float
+    strain: float | None
+
+
+@register_result("binding_affinity")
+class BindingAffinityResult(WorkflowResult):
+    """Result from a binding affinity workflow."""
+
+    _stjames_class = stjames.BindingAffinityWorkflow
+
+    def __repr__(self) -> str:
+        n = len(self.scores)
+        return f"<BindingAffinityResult scores={n}>"
+
+    @property
+    def scores(self) -> list[BindingAffinityScore]:
+        """Binding affinity scores for each scored pose."""
+        return [
+            BindingAffinityScore(
+                binding_affinity=r.binding_affinity,
+                strain=r.strain,
+            )
+            for r in (self._workflow.binding_affinity_results or [])
+        ]
+
+    @property
+    def messages(self) -> list[Message]:
+        """Any messages or warnings from the workflow."""
+        return parse_messages(self._workflow.messages)
+
+
+def submit_binding_affinity_workflow(
+    protein: str | Protein,
+    ligand_residue_name: str | None = None,
+    ligand_structures: list[StructureInput] | None = None,
+    binding_affinity_settings: SinglePointEnergySettings | None = None,
+    name: str = "Binding Affinity Workflow",
+    folder_uuid: str | None = None,
+    folder: Folder | None = None,
+    max_credits: int | None = None,
+    webhook_url: str | None = None,
+    is_draft: bool = False,
+) -> Workflow:
+    """
+    Submits a binding affinity workflow to the API.
+
+    Scores ligand poses using SQM-based energies. Two submission modes:
+
+    **Mode 1 — holo protein:** protein already contains the bound ligand. Pass
+    ``ligand_residue_name`` to identify which residue is the ligand vs. the receptor.
+    Do not pass ``ligand_structures``.
+
+    **Mode 2 — apo protein + external poses:** protein has no bound ligand. Pass
+    ``ligand_structures`` with poses that are already in the protein's coordinate frame.
+    Do not pass ``ligand_residue_name``. When scoring multiple ligands, prefer this mode
+    over separate per-ligand workflows — all poses share the same pocket geometry.
+
+    :param protein: protein structure. Can be input as a UUID or a Protein object.
+    :param ligand_residue_name: residue name identifying the ligand in a holo protein PDB
+        (mode 1 only).
+    :param ligand_structures: external ligand poses to score, already in the protein's
+        coordinate frame. Must have 3D coordinates (mode 2 only).
+    :param binding_affinity_settings: SQM settings controlling geometry optimization and
+        energy evaluation. Defaults to PM6-D3H4X/COSMO optimization followed by
+        PM6-D3H4X/COSMO2 single-point in water.
+    :param name: name of the workflow.
+    :param folder_uuid: UUID of the folder to place the workflow in.
+    :param folder: Folder object to store the workflow in.
+    :param max_credits: maximum number of credits to use for the workflow.
+    :param webhook_url: URL that Rowan will POST to when the workflow completes.
+    :param is_draft: if True, submit the workflow as a draft without starting execution.
+    :returns: Workflow object representing the submitted workflow.
+    :raises ValueError: if folder arguments conflict.
+    :raises requests.HTTPError: if the request to the API fails.
+    """
+    if folder and folder_uuid:
+        raise ValueError("Provide either `folder` or `folder_uuid`, not both.")
+    if folder:
+        folder_uuid = folder.uuid
+    if isinstance(protein, Protein):
+        protein = protein.uuid
+
+    mol_dicts: list[dict] = []
+    if ligand_structures:
+        for mol in ligand_structures:
+            require_coordinates(mol)
+            mol_dicts.append(molecule_to_dict(mol))
+
+    workflow = stjames.BindingAffinityWorkflow(
+        protein=protein,
+        ligand_residue_name=ligand_residue_name,
+        ligand_structures=mol_dicts or [],
+        binding_affinity_settings=binding_affinity_settings or SinglePointEnergySettings(),
+    )
+
+    data = {
+        "workflow_type": "binding_affinity",
+        "workflow_data": workflow.model_dump(serialize_as_any=True, mode="json"),
+        "name": name,
+        "folder_uuid": folder_uuid,
+        "max_credits": max_credits,
+        "webhook_url": webhook_url,
+        "is_draft": is_draft,
+    }
+
+    with api_client() as client:
+        response = client.post("/workflow", json=data)
+        response.raise_for_status()
+        return Workflow(**response.json())

rowan/workflows/covalent_inhibitor_scan.py

@@ -0,0 +1,129 @@
+"""Covalent inhibitor scan workflow - bond scan for a covalent inhibitor reaction."""
+
+from dataclasses import dataclass
+
+import stjames
+
+from ..folder import Folder
+from ..molecule import Molecule
+from ..protein import Protein
+from ..utils import api_client
+from .base import Workflow, WorkflowResult, register_result
+
+
+@dataclass(frozen=True, slots=True)
+class CovalentInhibitorScanPoint:
+    """
+    A point along the covalent inhibitor bond scan.
+
+    :param index: index of the point along the scan
+    :param distance: scanned bond distance, in Å
+    :param molecule: Molecule at the point
+    :param energy: implicit-solvent single-point energy at this geometry, in Hartree
+    :param uuid: UUID of the scan-point calculation
+    """
+
+    index: int
+    distance: float
+    molecule: Molecule
+    energy: float | None
+    uuid: str | None
+
+
+@register_result("covalent_inhibitor_scan")
+class CovalentInhibitorScanResult(WorkflowResult):
+    """Result from a covalent inhibitor scan workflow."""
+
+    _stjames_class = stjames.CovalentInhibitorScanWorkflow
+
+    def __repr__(self) -> str:
+        return f"<CovalentInhibitorScanResult points={len(self.scan_points)}>"
+
+    @property
+    def scan_points(self) -> list[CovalentInhibitorScanPoint]:
+        """Points along the scan, ordered by scan index (scan_start to scan_stop)."""
+        return [
+            CovalentInhibitorScanPoint(
+                index=p.index,
+                distance=p.distance,
+                molecule=Molecule.from_stjames(p.molecule),
+                energy=p.energy,
+                uuid=p.uuid,
+            )
+            for p in self._workflow.scan_points
+        ]
+
+    def get_energies(self) -> list[tuple[float, float | None]]:
+        """
+        Get scan distances paired with single-point energies.
+
+        :returns: List of (distance, energy) tuples, in Å and Hartree respectively.
+        """
+        return [(p.distance, p.energy) for p in self.scan_points]
+
+
+def submit_covalent_inhibitor_scan_workflow(
+    protein: str | Protein,
+    protein_reactive_atom_index: int,
+    ligand_reactive_atom_index: int,
+    ligand_smiles: str,
+    settings: stjames.CovalentInhibitorScanSettings | None = None,
+    name: str = "Covalent Inhibitor Scan Workflow",
+    folder_uuid: str | None = None,
+    folder: Folder | None = None,
+    max_credits: int | None = None,
+    webhook_url: str | None = None,
+    is_draft: bool = False,
+) -> Workflow:
+    """
+    Submits a covalent inhibitor scan workflow to the API.
+
+    :param protein: covalently docked protein-ligand complex (protein plus the ligand as a
+        non-polymer residue). Can be a UUID or a Protein object.
+    :param protein_reactive_atom_index: 0-based index of the reacting protein atom, in PDB
+        record order.
+    :param ligand_reactive_atom_index: 0-based index of the reacting ligand atom, in PDB
+        record order.
+    :param ligand_smiles: SMILES of the ligand, whose net charge sets the ligand charge of the QM
+        cluster.
+    :param settings: settings controlling the scan. Defaults to
+        `stjames.CovalentInhibitorScanSettings()`.
+    :param name: name of the workflow.
+    :param folder_uuid: UUID of the folder to place the workflow in.
+    :param folder: Folder object to store the workflow in.
+    :param max_credits: maximum number of credits to use for the workflow.
+    :param webhook_url: URL that Rowan will POST to when the workflow completes.
+    :param is_draft: if True, submit the workflow as a draft without starting execution.
+    :returns: Workflow object representing the submitted workflow.
+    :raises requests.HTTPError: if the request to the API fails.
+    """
+    if folder and folder_uuid:
+        raise ValueError("Provide either `folder` or `folder_uuid`, not both.")
+    if folder:
+        folder_uuid = folder.uuid
+    if isinstance(protein, Protein):
+        protein = protein.uuid
+
+    workflow = stjames.CovalentInhibitorScanWorkflow(
+        protein=protein,
+        protein_reactive_atom_index=protein_reactive_atom_index,
+        ligand_reactive_atom_index=ligand_reactive_atom_index,
+        initial_smiles=ligand_smiles,
+        settings=settings or stjames.CovalentInhibitorScanSettings(),
+    )
+
+    data = {
+        "workflow_type": "covalent_inhibitor_scan",
+        "workflow_data": workflow.model_dump(mode="json"),
+        "initial_smiles": ligand_smiles,
+        "name": name,
+        "folder_uuid": folder_uuid,
+        "max_credits": max_credits,
+        "webhook_url": webhook_url,
+        "is_draft": is_draft,
+    }
+
+    with api_client() as client:
+        response = client.post("/workflow", json=data)
+        response.raise_for_status()
+        return Workflow(**response.json())

rowan/workflows/docking.py

@@ -1,5 +1,6 @@
 """Docking workflow - molecular docking to protein targets."""
 
+import warnings
 from dataclasses import dataclass
 
 import stjames
@@ -21,7 +22,11 @@ from .base import (
 
 @dataclass(frozen=True, slots=True)
 class DockingScore:
-    """A docking pose with its score."""
+    """A docking pose with its scores.
+
+    :param score: Docking score in kcal/mol.
+    :param mmgbsa_score: MM/GBSA binding free energy estimate in kcal/mol.
+    """
 
     score: float
     pose: str | None = None
@@ -29,6 +34,7 @@ class DockingScore:
     posebusters_valid: bool = False
     strain: float | None = None
     rmsd: float | None = None
+    mmgbsa_score: float | None = None
 
 
 @register_result("docking")
@@ -59,6 +65,7 @@ class DockingResult(WorkflowResult):
                 posebusters_valid=s.posebusters_valid,
                 strain=s.strain,
                 rmsd=s.rmsd,
+                mmgbsa_score=s.mmgbsa_score,
             )
             for s in self._workflow.scores
         ]
@@ -146,10 +153,11 @@ def submit_docking_workflow(
     protein: str | Protein,
     pocket: list[list[float]],
     initial_molecule: StructureInput,
-    executable: str = "vina",
-    scoring_function: str = "vinardo",
-    exhaustiveness: float = 8,
-    max_poses: int = 4,
+    docking_settings: stjames.VinaSettings | stjames.GninaSettings | None = None,
+    executable: str | None = None,
+    scoring_function: str | None = None,
+    exhaustiveness: float | None = None,
+    max_poses: int | None = None,
     do_csearch: bool = False,
     do_optimization: bool = False,
     do_pose_refinement: bool = True,
@@ -166,10 +174,17 @@ def submit_docking_workflow(
     :param protein: Protein to dock. Can be input as a uuid or a Protein object.
     :param pocket: Binding pocket as ``[[cx, cy, cz], [sx, sy, sz]]`` — center (Å) and box size (Å).
     :param initial_molecule: Initial molecule to be docked.
-    :param executable: Which docking implementation to use.
-    :param scoring_function: Which docking scoring function to use.
-    :param exhaustiveness: Which exhaustiveness to employ.
-    :param max_poses: Maximum number of poses generated per input conformer.
+    :param docking_settings: Settings controlling the docking engine, e.g. ``VinaSettings`` or
+        ``GninaSettings`` (for noncovalent or covalent gnina docking). If provided, the deprecated
+        ``executable``, ``scoring_function``, ``exhaustiveness``, and ``max_poses`` are ignored.
+    :param executable: Deprecated, use `docking_settings=VinaSettings(executable=...)` instead.
+        Which Vina docking implementation to use.
+    :param scoring_function: Deprecated, use `docking_settings=VinaSettings(scoring_function=...)`
+        instead. Which Vina docking scoring function to use.
+    :param exhaustiveness: Deprecated, use `docking_settings=VinaSettings(exhaustiveness=...)`
+        instead. Which exhaustiveness to employ.
+    :param max_poses: Deprecated, use `docking_settings=VinaSettings(max_poses=...)` instead.
+        Maximum number of poses generated per input conformer.
     :param do_csearch: Whether to perform a conformational search on the ligand.
     :param do_optimization: Whether to perform an optimization on the ligand.
     :param do_pose_refinement: Whether or not to optimize output poses.
@@ -192,12 +207,26 @@ def submit_docking_workflow(
     if isinstance(protein, Protein):
         protein = protein.uuid
 
-    docking_settings = stjames.VinaSettings(
-        executable=executable,
-        exhaustiveness=exhaustiveness,
-        max_poses=max_poses,
-        scoring_function=scoring_function,
-    )
+    legacy_vina_kwargs = {
+        k: v
+        for k, v in {
+            "executable": executable,
+            "exhaustiveness": exhaustiveness,
+            "max_poses": max_poses,
+            "scoring_function": scoring_function,
+        }.items()
+        if v is not None
+    }
+    if legacy_vina_kwargs:
+        warnings.warn(
+            "executable, scoring_function, exhaustiveness, and max_poses are deprecated; "
+            "pass docking_settings=VinaSettings(...) instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+    if docking_settings is None:
+        docking_settings = stjames.VinaSettings(**legacy_vina_kwargs)
 
     workflow = stjames.DockingWorkflow(
         initial_molecule=mol_dict,
@@ -210,7 +239,6 @@ def submit_docking_workflow(
     )
 
     workflow_data = workflow.model_dump(serialize_as_any=True, mode="json")
-    workflow_data["docking_settings"].setdefault("settings_type", "vina")
 
     data = {
         "workflow_type": "docking",

rowan/workflows/double_ended_ts_search.py

@@ -4,7 +4,8 @@ from dataclasses import dataclass
 from typing import Any
 
 import stjames
-from stjames.optimization.freezing_string_method import FSMSettings
+from stjames.optimization.band_method import NEBSettings
+from stjames.optimization.string_method import StringMethodSettings
 
 from ..calculation import Calculation, retrieve_calculation
 from ..folder import Folder
@@ -151,7 +152,7 @@ def submit_double_ended_ts_search_workflow(
     reactant: StructureInput,
     product: StructureInput,
     calculation_settings: stjames.Settings | dict[str, Any] | None = None,
-    search_settings: FSMSettings | dict[str, Any] | None = None,
+    search_settings: StringMethodSettings | NEBSettings | dict[str, Any] | None = None,
     optimize_inputs: bool = True,
     optimize_ts: bool = True,
     name: str = "Double-Ended TS Search Workflow",
@@ -167,7 +168,7 @@ def submit_double_ended_ts_search_workflow(
     :param reactant: reactant Molecule.
     :param product: product Molecule.
     :param calculation_settings: Settings to use for calculations. Defaults to omol25_conserving_s.
-    :param search_settings: Settings for the transition state search. Defaults to FSMSettings().
+    :param search_settings: Settings for the transition state search; resolves to FSM
     :param optimize_inputs: Whether to optimize the reactant and product before the search.
     :param optimize_ts: Whether to optimize the found transition state.
     :param name: name of the workflow.
@@ -195,7 +196,7 @@ def submit_double_ended_ts_search_workflow(
         reactant=reactant_dict,
         product=product_dict,
         calculation_settings=calculation_settings,
-        search_settings=search_settings or FSMSettings(),
+        search_settings=search_settings or StringMethodSettings(),
         optimize_inputs=optimize_inputs,
         optimize_ts=optimize_ts,
     )

rowan/workflows/irc.py

@@ -165,6 +165,44 @@ class IRCResult(WorkflowResult):
         energies: list[float] = [m.energy for m in self.backward_molecules if m.energy is not None]
         return to_relative_kcal(energies) if relative else energies
 
+    @property
+    def forward_step_sizes(self) -> list[float]:
+        """Actual step sizes taken along the forward IRC path (Å√amu)."""
+        return list(self._workflow.step_sizes_forward)
+
+    @property
+    def backward_step_sizes(self) -> list[float]:
+        """Actual step sizes taken along the backward IRC path (Å√amu)."""
+        return list(self._workflow.step_sizes_backward)
+
+    @property
+    def forward_endpoint_calculation(self) -> Calculation | None:
+        """Optimization of the forward endpoint (if ``optimize_endpoints=True``, lazily fetched)."""
+        if "forward_endpoint_calc" not in self._cache:
+            uuid = self._workflow.endpoint_opt_forward
+            self._cache["forward_endpoint_calc"] = retrieve_calculation(uuid) if uuid else None
+        return self._cache["forward_endpoint_calc"]
+
+    @property
+    def backward_endpoint_calculation(self) -> Calculation | None:
+        """Optimization of backward endpoint (if ``optimize_endpoints=True``, lazily fetched)."""
+        if "backward_endpoint_calc" not in self._cache:
+            uuid = self._workflow.endpoint_opt_backward
+            self._cache["backward_endpoint_calc"] = retrieve_calculation(uuid) if uuid else None
+        return self._cache["backward_endpoint_calc"]
+
+    @property
+    def forward_endpoint_molecule(self) -> Molecule | None:
+        """Optimized forward endpoint molecule (if ``optimize_endpoints=True``)."""
+        calc = self.forward_endpoint_calculation
+        return calc.molecule if calc else None
+
+    @property
+    def backward_endpoint_molecule(self) -> Molecule | None:
+        """Optimized backward endpoint molecule (if ``optimize_endpoints=True``)."""
+        calc = self.backward_endpoint_calculation
+        return calc.molecule if calc else None
+
 
 def submit_irc_workflow(
     initial_molecule: StructureInput,
@@ -177,6 +215,7 @@ def submit_irc_workflow(
     preopt: bool = True,
     step_size: float = 0.05,
     max_irc_steps: int = 30,
+    optimize_endpoints: bool = False,
     name: str = "IRC Workflow",
     folder_uuid: str | None = None,
     folder: Folder | None = None,
@@ -195,8 +234,9 @@ def submit_irc_workflow(
     :param engine: Engine for the calculation (and optional preopt)
     :param pbc_dft_settings: PBC DFT settings for the IRC (and optional preopt)
     :param preopt: Whether to perform a pre-optimization of the TS guess
-    :param step_size: Step size for the IRC calculation
+    :param step_size: Step size for the IRC calculation (0.001-0.5 Å√amu)
     :param max_irc_steps: Maximum number of IRC steps to perform
+    :param optimize_endpoints: Whether to optimize the endpoint geometries once the IRC completes
     :param name: Name for the workflow
     :param folder_uuid: UUID of the folder to place the workflow in
     :param folder: Folder object to store the workflow in
@@ -244,6 +284,7 @@ def submit_irc_workflow(
         preopt=preopt,
         step_size=step_size,
         max_irc_steps=max_irc_steps,
+        optimize_endpoints=optimize_endpoints,
     )
 
     data = {

rowan/workflows/pose_analysis_md.py

@@ -73,6 +73,11 @@ class PoseAnalysisMDResult(WorkflowResult):
             for t in raw
         ]
 
+    @property
+    def hydration_sites(self) -> list[stjames.HydrationSite]:
+        """Hydration sites identified across all trajectories."""
+        return self._workflow.hydration_sites or []
+
     @property
     def average_rmsds(self) -> list[float | None]:
         """Average ligand RMSD per trajectory (Angstrom)."""

rowan/workflows/protein_cofolding.py

@@ -80,6 +80,7 @@ class CofoldingResult:
     :param scores: Confidence scores for the prediction.
     :param affinity_score: Predicted binding affinity (if computed).
     :param strain: Ligand strain energy (if computed).
+    :param mmgbsa_score: MM/GBSA binding free energy estimate in kcal/mol (if computed).
     :param posebusters_valid: Whether the pose passes PoseBusters validation.
     :param lddt: Per-residue LDDT confidence scores.
     :param pose_uuid: UUID of the pose.
@@ -90,6 +91,7 @@ class CofoldingResult:
     scores: CofoldingScores | None = None
     affinity_score: AffinityScore | None = None
     strain: float | None = None
+    mmgbsa_score: float | None = None
     posebusters_valid: bool | None = None
     lddt: list[float] | None = None
     pose_uuid: str | None = None
@@ -197,6 +199,7 @@ class ProteinCofoldingResult(WorkflowResult):
                     scores=scores,
                     affinity_score=affinity_score,
                     strain=getattr(r, "strain", None),
+                    mmgbsa_score=getattr(r, "mmgbsa_score", None),
                     posebusters_valid=getattr(r, "posebusters_valid", None),
                     lddt=list(lddt) if lddt else None,
                     pose_uuid=getattr(r, "pose", None),

rowan/workflows/rbfe_graph.py

@@ -97,6 +97,9 @@ def submit_relative_binding_free_energy_graph_workflow(
     greedy_k_min_cut: int = 3,
     refine_cutoff: float | None = None,
     seed_graph: RBFEGraph | None = None,
+    generate_intermediate_ligands: bool = False,
+    intermediate_max_dummy_atoms: int = 25,
+    intermediate_min_dummy_atom_improvement: int = 5,
     name: str = "RBFE Graph",
     folder_uuid: str | None = None,
     folder: Folder | None = None,
@@ -120,6 +123,12 @@ def submit_relative_binding_free_energy_graph_workflow(
     :param seed_graph: RBFE graph from a prior run to extend, as returned by a
         completed result's ``graph``. Its existing edges (and any computed results)
         are preserved, and only edges for newly added ligands are built.
+    :param generate_intermediate_ligands: Generate virtual intermediate ligands to make
+        difficult edges easier.
+    :param intermediate_max_dummy_atoms: An edge with more dummy atoms than this is split
+        when a generated intermediate brings both resulting legs back to at most this value.
+    :param intermediate_min_dummy_atom_improvement: Minimum reduction in the worst leg's
+        dummy-atom count required for a generated intermediate to be accepted.
     :param name: Name of the workflow.
     :param folder_uuid: UUID of the folder to place the workflow in.
     :param folder: Folder object to store the workflow in.
@@ -169,6 +178,9 @@ def submit_relative_binding_free_energy_graph_workflow(
         greedy_k_min_cut=greedy_k_min_cut,
         refine_cutoff=refine_cutoff,
         seed_graph=seed_graph,
+        generate_intermediate_ligands=generate_intermediate_ligands,
+        intermediate_max_dummy_atoms=intermediate_max_dummy_atoms,
+        intermediate_min_dummy_atom_improvement=intermediate_min_dummy_atom_improvement,
     )
 
     data = {

{rowan_python-3.1.4.dist-info → rowan_python-3.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rowan-python
-Version: 3.1.4
+Version: 3.1.6
 Summary: Rowan Python Library
 Project-URL: Homepage, https://github.com/rowansci/rowan-client
 Project-URL: Bug Tracker, https://github.com/rowansci/rowan-client/issues
@@ -11,7 +11,7 @@ Requires-Dist: httpx
 Requires-Dist: nest-asyncio
 Requires-Dist: rdkit
 Requires-Dist: setuptools
-Requires-Dist: stjames>=0.0.208
+Requires-Dist: stjames>=0.0.228
 Description-Content-Type: text/markdown
 
 # Rowan Python Library

{rowan_python-3.1.4.dist-info → rowan_python-3.1.6.dist-info}/RECORD

@@ -1,34 +1,36 @@
-rowan/__init__.py,sha256=AfjV9IsjgykiU39Eh9vjUP_3at-OSqqhSgNhPxutma0,1456
+rowan/__init__.py,sha256=95VjN9XTgEICFLCcB4oUbT_nsU_EvulDqMDJjBuSTI8,1714
 rowan/api_keys.py,sha256=TvG5l5MmQ3Qt8Z3Y7jCA_lcrwEHuI7xHy-KLbIdQ8_A,4793
 rowan/calculation.py,sha256=nuUtLTtn9D-FCM9TJl3h5euBgIYqa5fr5r_PSNBS7Xo,3809
 rowan/config.py,sha256=TejQKSxnzNKKTNL9-2bCLq6RvAh54oVA5Ivl1p_ZT8Q,20899
 rowan/constants.py,sha256=emCH4m9OL2Hm5E-6mJGM_FgzrK_JrZT-FiKJ6pMNQ4Y,84
 rowan/folder.py,sha256=RRg68dObluJ2RCTKX3rb7RxziOXOQUYxkfQSU2R5VMk,13708
-rowan/molecule.py,sha256=W6eBuIQAjZs5JiQFmyRnbcbj2Qy2XbZnm_J0WuMslG4,13881
+rowan/molecule.py,sha256=1l-3YCN_A75Uz_Q-dMWuhkeF8rhD1z2JQM7AENyjKYM,15512
 rowan/project.py,sha256=RtxYE9jv3Yz6fH5I56iDGRG5EbwlOHiSK-HF1uxc0d4,4582
 rowan/protein.py,sha256=T2JAqfncP80yV5gEWYA-TlpNY3WeWaNHPE0Xg5voU24,17968
 rowan/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rowan/types.py,sha256=MvcYvEYr6N9RXLal44MqsnMxoWfcBa-VLD_rGsW4HOc,591
 rowan/user.py,sha256=rOCYVhSoRY71fCG_OCSD7cLAWWnAMANWGitF3ogfq30,6212
 rowan/utils.py,sha256=DBphY1he8Vl3RNf6CbLp5BSX9RG5EfHzhMs-9TmcE_g,4299
-rowan/workflows/__init__.py,sha256=ohl2q-Nqgs4E9cl5KIGigQgE2ifiTmY5dib5R_qNxO4,4510
+rowan/workflows/__init__.py,sha256=pkmAl8aPDznu15bSuRW0j8id-B7Xmzy_tq3LgZfQ7NQ,4786
 rowan/workflows/admet.py,sha256=jDx1Kkgmp0XaeojPzaCFY_yUwvqtSM7Cezps-93cqPw,2865
-rowan/workflows/analogue_docking.py,sha256=IxVaYD8ITsLFfvZ6N7v4KmvIS25DcUQkv-_tMhEfG_4,9707
+rowan/workflows/analogue_docking.py,sha256=TshOw71RmK5XaaTIHz_Q1opiDU9x1L38tXwxoYUZaxY,9756
 rowan/workflows/base.py,sha256=k858otXLuorw4MZ1hvqZI_m0n_38htC7Hy3OMCX1TOA,32961
-rowan/workflows/basic_calculation.py,sha256=CnAnbRYrnjbxgcPAZxPUARUjaqPCnAAjf-RFku8R1r0,11240
+rowan/workflows/basic_calculation.py,sha256=EovymT6fV6mxmt4G4kRtiskSPGB7w7KAHqBaGtgQI2Q,12941
 rowan/workflows/batch_docking.py,sha256=ePnb1hcsmnUfffl1-k9HNkOC09RjY9bZS9XcqAGNeFs,3621
 rowan/workflows/bde.py,sha256=1ieYUeu-5Lg637eSjhbRr_6qSIiIcjhsLOzaA4zbg3o,6681
+rowan/workflows/binding_affinity.py,sha256=Pengz5gmhYvRd3P6yTe1p7nLZnDENp_gwDJo2q5kiEg,5089
 rowan/workflows/conformer_search.py,sha256=9_DpRfmeNWIVm68Y95zcHCK5Q0yt9le6W70rMeIQndY,15467
 rowan/workflows/constants.py,sha256=el8jWE9gnGTLNWn5_n_V0H362vIRneOqgy7BOQ8CScg,575
+rowan/workflows/covalent_inhibitor_scan.py,sha256=BNqGLE2CjSlkOlXj_7KcsX9GEstMD3Ts-v2qIlRWK48,4717
 rowan/workflows/descriptors.py,sha256=QjjpzPDpAO_EhPOK--gle6sGpVHMpdAs_yrvC0oiseY,3092
-rowan/workflows/docking.py,sha256=VTauRB6knysUsAzGhEhI95F6BQLAuZbNEA468wByohc,8031
-rowan/workflows/double_ended_ts_search.py,sha256=eZNEXhfh5W5j5JcEzKnKMMf9HPbIM6HDLnzoh_vVFXk,8115
+rowan/workflows/docking.py,sha256=SfFzZER-fYGPn9OZyEE9BSAestjCbbUaP4z9OapA1ko,9391
+rowan/workflows/double_ended_ts_search.py,sha256=nse7oK-8R5h_FtpZZAzes0TQCs2XOdEbdyZFOECK8B0,8193
 rowan/workflows/electronic_properties.py,sha256=MXbsI4OHyXWt3f4Qc5g7-SNjyyEoYzocWVdcP1H06sY,8436
 rowan/workflows/fukui.py,sha256=Lyx3FgSdidzPMj-PpSzOb9uXCZj2S_52p8zBYxBbprg,4412
 rowan/workflows/hydrogen_bond_donor_acceptor_strength.py,sha256=xgFFemIZpIOkgkiYx20TmCexWNxNgRZl4H4t-zfQqUE,5254
 rowan/workflows/interaction_energy_decomposition.py,sha256=wK9Mc9uGmFBG8H03LRRRz3nZzM6p7Z2ol1yiZbUB5ec,6176
 rowan/workflows/ion_mobility.py,sha256=GqVVPRffaBJvygB3mwbMJq2aW7y19J3AnkDx_ZMIRss,4021
-rowan/workflows/irc.py,sha256=Zf1zh-UjTrQnZ4fwQ4jDJKh80nsyMymAPK6qUoOShKI,10075
+rowan/workflows/irc.py,sha256=qA8rLvhSkyOBBDtUw8Yq1iaRHiCUil0pI_HsMhVcuEQ,12069
 rowan/workflows/macropka.py,sha256=IxGwr9LziIwj_x6pXEhJN6SywS_KULziuYoETNqM370,5684
 rowan/workflows/membrane_permeability.py,sha256=wHZ1IPlXwBB343uVAm7EuhedcMPd-Uy4jMqHfXRHwqY,4680
 rowan/workflows/msa.py,sha256=k_FlxxtdgvmxDN3LyLDEQeFfI8_lyBJz1KFtz3S4oNo,4816
@@ -36,11 +38,11 @@ rowan/workflows/multistage_optimization.py,sha256=04kZPC3SmVOxqEQOwyBrS3DlelM-b8
 rowan/workflows/nmr.py,sha256=68be_Xgiy1AykGdIL4fR1pqKllD1nLm3IidsStzKtz4,5521
 rowan/workflows/pka.py,sha256=NZ-3i-cH_b7YOHj2iq0roXEcZmC8SYapmzMOX6ObRqw,8546
 rowan/workflows/pocket_detection.py,sha256=aGHY0puxekp4c4nsNYHcvKCe1fsetygL04BcSvNFvE8,3864
-rowan/workflows/pose_analysis_md.py,sha256=XJIfvn-H7GA6lVtw9uKjlgznVSSsr9bJiDt_PjKlPbA,11572
+rowan/workflows/pose_analysis_md.py,sha256=5TRsCBFD0QObE5tpmCOxi137xsKMfQrRO6ef8TLrnkk,11767
 rowan/workflows/protein_binder_design.py,sha256=pgywTQDuXHplZYka-61_S6CC4WTPDCwJrbupp825eC4,9281
-rowan/workflows/protein_cofolding.py,sha256=CV13VUHC0NLDDaS1-GGTQ3RySkzEE30xzu1_4oPu6lo,16239
+rowan/workflows/protein_cofolding.py,sha256=haT0liJorxyHgO02WX8WslqAu7Dc7QOSs6VbE9ZJwuw,16433
 rowan/workflows/protein_md.py,sha256=zqKEtL514uchgbxsyO4vhokzTU-X4lTFA1BM5O8HvTU,10117
-rowan/workflows/rbfe_graph.py,sha256=7UJA3ZBbvtaB9l1KQi9279Pc89moVnBHO-XJpxEr5uQ,7238
+rowan/workflows/rbfe_graph.py,sha256=0eMfvwtQhyajUC8T-bhdcYNKi6Pkja6x6dHjCnEwxPw,8081
 rowan/workflows/redox_potential.py,sha256=bBeT1K9XGVpjCFZeeuv7Vtr3EYHN2okJ4LqYc3gMV04,5427
 rowan/workflows/relative_binding_free_energy_perturbation.py,sha256=vi5Qj5aDAERtjcHDsgzI6vRV_BZJnJ8boOj5aG6GXzo,13817
 rowan/workflows/scan.py,sha256=R5Y6Md3ohPoFVJ4NYvx3_k3JNwMnVw1CDsNPD9S8sr4,7518
@@ -49,7 +51,7 @@ rowan/workflows/solvent_dependent_conformers.py,sha256=Z2xESmcM8WcTsR2TSTUa--Rrh
 rowan/workflows/spin_states.py,sha256=rjkgie2-XVNIN7O6P93yn6EPv9Ogjy8iTj3ufZIsUgY,9331
 rowan/workflows/strain.py,sha256=kCW_BlX__sdQG1JVbFZuB-57rkpnxa_JCw3h4uKdGDk,6425
 rowan/workflows/tautomer_search.py,sha256=mbRl0ZJ7wibueRF8c8_idhXJ1rtwg7LBt--5QwQ_Cck,5767
-rowan_python-3.1.4.dist-info/METADATA,sha256=qogpVoI_aoX_24Z2diW8JdOR2sphEYp-HuLtTFvvN-w,2052
-rowan_python-3.1.4.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-rowan_python-3.1.4.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
-rowan_python-3.1.4.dist-info/RECORD,,
+rowan_python-3.1.6.dist-info/METADATA,sha256=DNhG5-OE8U_DwL4OgWgBf3tKivdvSYRMW9kmh_kq48g,2052
+rowan_python-3.1.6.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+rowan_python-3.1.6.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
+rowan_python-3.1.6.dist-info/RECORD,,

{rowan_python-3.1.4.dist-info → rowan_python-3.1.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any