rowan-python 3.1.3__py3-none-any.whl → 3.1.5__py3-none-any.whl

rowan/__init__.py

@@ -2,6 +2,11 @@
 from . import constants
 from stjames import (
     Atom,
+    BandStructure,
+    BindingPoseContact,
+    HydrationBridgeResidue,
+    HydrationSite,
+    ConformerGenSettings,
     Constraint,
     ConstraintType,
     ConformerClusteringSettings,
@@ -14,15 +19,20 @@ from stjames import (
     KMeansClusteringSettings,
     Method,
     Mode,
+    MSAFormat,
     MultiStageOptSettings,
     OpenConfSettings,
     OptimizationSettings,
     PBCDFTSettings,
     PeriodicCell,
+    ProteinSequence,
+    ScanSettings,
     Settings,
     Solvent,
     SolventSettings,
+    SinglePointEnergySettings,
     Task,
+    VibrationalMode,
 )
 from stjames.workflows.relative_binding_free_energy_perturbation import RBFEGraph, RBFEGraphEdge
 from stjames.excited_state_settings import TDDFTSettings

rowan/calculation.py

@@ -2,6 +2,7 @@
 
 from typing import Self
 
+import httpx
 import stjames
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -62,10 +63,13 @@ class Calculation(BaseModel):
         :param in_place: If True, update this instance in-place. If False, return new instance.
         :returns: Updated Calculation object.
         """
-        with api_client() as client:
-            response = client.get(f"/calculation/{self.uuid}/stjames")
-            response.raise_for_status()
-            data = response.json()
+        try:
+            with api_client() as client:
+                response = client.get(f"/calculation/{self.uuid}/stjames")
+                response.raise_for_status()
+                data = response.json()
+        except httpx.TimeoutException as e:
+            raise TimeoutError(f"Timed out fetching calculation {self.uuid}.") from e
 
         molecules = _parse_molecules(data.get("molecules", []))
 
@@ -94,11 +98,15 @@ def retrieve_calculation(uuid: str) -> Calculation:
     :param uuid: UUID of the calculation to retrieve.
     :returns: Calculation object with the fetched data.
     :raises requests.HTTPError: If the API request fails.
+    :raises TimeoutError: If the response times out.
     """
-    with api_client() as client:
-        response = client.get(f"/calculation/{uuid}/stjames")
-        response.raise_for_status()
-        data = response.json()
+    try:
+        with api_client() as client:
+            response = client.get(f"/calculation/{uuid}/stjames")
+            response.raise_for_status()
+            data = response.json()
+    except httpx.TimeoutException as e:
+        raise TimeoutError(f"Timed out fetching calculation {uuid}.") from e
 
     molecules = _parse_molecules(data.get("molecules", []))
 

rowan/folder.py

@@ -1,11 +1,16 @@
+from __future__ import annotations
+
 from datetime import datetime
-from typing import Any, Self
+from typing import TYPE_CHECKING, Any, Self
 
 from pydantic import BaseModel
 
 from .project import default_project, retrieve_project
 from .utils import api_client, get_project_uuid
 
+if TYPE_CHECKING:
+    from .workflows.base import Workflow
+
 
 class Folder(BaseModel):
     """
@@ -121,6 +126,77 @@ class Folder(BaseModel):
         """
         print_folder_tree(self.uuid, max_depth, show_uuids)
 
+    def children(self, size: int = 100) -> list[Folder]:
+        """
+        List all child folders directly inside this folder.
+
+        :param size: Maximum number of child folders to return.
+        :returns: List of child Folder objects.
+        :raises HTTPError: If the API request fails.
+        """
+        return list_folders(parent_uuid=self.uuid, size=size)
+
+    def workflows(self, size: int = 100) -> list[Workflow]:
+        """
+        List all workflows directly inside this folder.
+
+        :param size: Maximum number of workflows to return.
+        :returns: List of Workflow objects.
+        :raises HTTPError: If the API request fails.
+        """
+        from .workflows.base import list_workflows
+
+        return list_workflows(parent_uuid=self.uuid, size=size)
+
+    def contents(self, size: int = 100) -> list[Folder | Workflow]:
+        """
+        List everything directly inside this folder, both child folders and workflows.
+
+        Folders come first, followed by workflows. For a single type, use :func:`children`
+        or :func:`workflows`.
+
+        :param size: Maximum number of items of each type to return.
+        :returns: List of Folder and Workflow objects.
+        :raises HTTPError: If the API request fails.
+        """
+        return [*self.children(size=size), *self.workflows(size=size)]
+
+    def parent(self) -> Folder | None:
+        """
+        Retrieve the parent folder, or None if this is a root folder.
+
+        :returns: Parent Folder, or None if there is no parent.
+        :raises HTTPError: If the API request fails.
+        """
+        if self.parent_uuid is None:
+            return None
+        return retrieve_folder(self.parent_uuid)
+
+    def __truediv__(self, name: str) -> Folder:
+        """
+        Traverse into a child folder by name using the ``/`` operator.
+
+        Example::
+
+            root = rowan.root_folder()
+            subfolder = root / "CDK2" / "docking"
+
+        :param name: Exact name of the child folder to navigate into.
+        :returns: Child Folder with the given name.
+        :raises ValueError: If no child with that name exists, or if multiple children share
+            the same name (use :func:`children` and select by UUID to disambiguate).
+        """
+        matches = [f for f in self.children(size=200) if f.name == name]
+        if not matches:
+            raise ValueError(f"No child folder named {name!r} in {self.name!r} ({self.uuid})")
+        if len(matches) > 1:
+            uuids = ", ".join(f.uuid for f in matches)
+            raise ValueError(
+                f"Multiple child folders named {name!r} in {self.name!r} ({self.uuid}). "
+                f"Use retrieve_folder() with one of these UUIDs to disambiguate: {uuids}"
+            )
+        return matches[0]
+
 
 def retrieve_folder(uuid: str) -> Folder:
     """
@@ -147,6 +223,9 @@ def list_folders(
     """
     Retrieve a list of folders based on the specified criteria.
 
+    If no ``parent_uuid`` is given and a project is active (via :func:`set_project` or
+    ``rowan.project_uuid``), lists folders rooted at that project's root folder.
+
     :param parent_uuid: UUID of the parent folder to filter by.
     :param name_contains: Substring to search for in folder names.
     :param public: Filter folders by their public status.
@@ -156,6 +235,11 @@ def list_folders(
     :returns: List of Folder objects that match the search criteria.
     :raises requests.HTTPError: if the request to the API fails.
     """
+    if parent_uuid is None:
+        if project_uuid := get_project_uuid():
+            parent_uuid = retrieve_project(project_uuid).root_folder_uuid
+        else:
+            parent_uuid = default_project().root_folder_uuid
 
     params: dict[str, Any] = {
         "page": page,
@@ -189,6 +273,9 @@ def create_folder(
     """
     Create a new folder.
 
+    If no ``parent_uuid`` is given and a project is active (via :func:`set_project` or
+    ``rowan.project_uuid``), the folder is created inside that project's root folder.
+
     :param name: Name of the folder.
     :param parent_uuid: UUID of the parent folder.
     :param notes: Description of the folder.
@@ -196,6 +283,12 @@ def create_folder(
     :param public: Whether the folder is public.
     :returns: Newly created folder.
     """
+    if parent_uuid is None:
+        if project_uuid := get_project_uuid():
+            parent_uuid = retrieve_project(project_uuid).root_folder_uuid
+        else:
+            parent_uuid = default_project().root_folder_uuid
+
     data = {
         "name": name,
         "parent_uuid": parent_uuid,
@@ -210,6 +303,32 @@ def create_folder(
     return Folder(**folder_data)
 
 
+def root_folder() -> Folder:
+    """
+    Get the root folder of the active project.
+
+    The root folder is the top of the folder tree you navigate and store workflows in. Use the
+    active project set via :func:`set_project` (or ``rowan.project_uuid``), falling back to the
+    default project.
+
+    Example::
+
+        root = rowan.root_folder()
+        for child in root.children():
+            print(child.name)
+        batch = root / "CDK2" / "docking"
+
+    :returns: Root Folder of the active or default project.
+    :raises HTTPError: If the API request fails.
+    """
+    if project_uuid := get_project_uuid():
+        root_uuid = retrieve_project(project_uuid).root_folder_uuid
+    else:
+        root_uuid = default_project().root_folder_uuid
+    assert root_uuid is not None
+    return retrieve_folder(root_uuid)
+
+
 def get_folder(path: str, create: bool = True) -> Folder:
     """
     Get a folder by name or nested path within the default project.

rowan/molecule.py

@@ -1,5 +1,7 @@
 """Molecule class for representing molecular structures and computed properties."""
 
+import math
+import random
 from pathlib import Path
 from typing import Any, Self
 
@@ -235,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:
@@ -272,6 +318,77 @@ class Molecule(BaseModel):
         """
         return self._stjames.dihedral(i, j, k, l, degrees=degrees)
 
+    def perturb(self, stddev: float = 0.005) -> "Molecule":
+        """
+        Return a copy with random Gaussian noise added to each atom position.
+
+        Useful for breaking symmetry before resubmitting an optimization (e.g. when
+        a calculation is stuck in a saddle point or converges to an unwanted geometry).
+
+        :param stddev: standard deviation of the Gaussian displacement (Angstroms)
+        :returns: new Molecule with perturbed coordinates
+        """
+
+        def _gauss() -> float:
+            u1 = random.random()
+            u2 = random.random()
+            return math.sqrt(-2.0 * math.log(u1)) * math.cos(2.0 * math.pi * u2) * stddev
+
+        new_atoms = [
+            stjames.Atom(
+                atomic_number=atom.atomic_number,
+                position=(
+                    atom.position[0] + _gauss(),
+                    atom.position[1] + _gauss(),
+                    atom.position[2] + _gauss(),
+                ),
+                mass=atom.mass,
+            )
+            for atom in self._stjames.atoms
+        ]
+        new_mol = self._stjames.model_copy(update={"atoms": new_atoms})
+        return Molecule(_stjames=new_mol)
+
+    def displace_along_mode(self, mode: stjames.VibrationalMode, displacement: float) -> "Molecule":
+        """
+        Return a copy with atom positions displaced along a vibrational normal mode.
+
+        Requires a prior frequency calculation. For a transition state, the imaginary
+        mode has a negative frequency and points toward the reactant or product.
+
+        :param mode: vibrational mode to displace along, from ``vibrational_modes``
+        :param displacement: displacement distance along the normalized mode (Angstroms)
+        :returns: new Molecule with displaced coordinates
+        :raises ValueError: if the mode has no displacements or zero-norm displacements
+        """
+        raw = mode.displacements
+        if not raw:
+            raise ValueError(
+                "Vibrational mode has no displacements. "
+                "Rerun the calculation with frequencies=True to displace along a mode."
+            )
+        norm = math.sqrt(sum(x**2 + y**2 + z**2 for x, y, z in raw))
+        if norm == 0:
+            raise ValueError(
+                "Vibrational mode has zero-norm displacements. "
+                "This indicates malformed frequency output, try displacing along a different mode."
+            )
+
+        new_atoms = [
+            stjames.Atom(
+                atomic_number=atom.atomic_number,
+                position=(
+                    atom.position[0] + (dx / norm) * displacement,
+                    atom.position[1] + (dy / norm) * displacement,
+                    atom.position[2] + (dz / norm) * displacement,
+                ),
+                mass=atom.mass,
+            )
+            for atom, (dx, dy, dz) in zip(self._stjames.atoms, raw, strict=True)
+        ]
+        new_mol = self._stjames.model_copy(update={"atoms": new_atoms})
+        return Molecule(_stjames=new_mol)
+
 
 def load_named_ligands(path: Path | str) -> dict[str, Molecule]:
     """

rowan/protein.py

@@ -1,4 +1,5 @@
 import time
+import warnings
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Self
@@ -39,6 +40,85 @@ class Protein(BaseModel):
     def __repr__(self) -> str:
         return f"<Protein name='{self.name}' created_at='{self.created_at}' uuid='{self.uuid}'>"
 
+    @property
+    def chains(self) -> list[str]:
+        """Polymer chain IDs present in this protein."""
+        if not self.data:
+            return []
+        model = self.data["models"][0]
+        chain_ids: set[str] = set(model["polymer"].keys())
+        for section in ("non_polymer", "water", "branched"):
+            for entity in model.get(section, {}).values():
+                if chain := entity.get("polymer"):
+                    chain_ids.add(chain)
+        return list(chain_ids)
+
+    def select_chains(self, chains: list[str]) -> "Protein":
+        """
+        Create a new protein record containing only the specified chains.
+
+        :param chains: Chain IDs to keep (e.g. ``["A"]``).
+        :returns: New Protein object with only the selected chains.
+        :raises ValueError: If any requested chain is not present.
+        :raises requests.HTTPError: If the API request fails.
+        """
+        if not self.data:
+            raise ValueError("Protein data not loaded — call refresh() first.")
+        available = self.chains
+        missing = [c for c in chains if c not in available]
+        if missing:
+            raise ValueError(f"Chain(s) {missing} not found. Available: {available}")
+
+        chain_set = set(chains)
+        model = self.data["models"][0]
+
+        filtered_polymer = {k: v for k, v in model["polymer"].items() if k in chain_set}
+        filtered_non_polymer = {
+            k: v for k, v in model["non_polymer"].items() if v.get("polymer") in chain_set
+        }
+        filtered_water = {k: v for k, v in model["water"].items() if v.get("polymer") in chain_set}
+        filtered_branched = {
+            k: v for k, v in model["branched"].items() if v.get("polymer") in chain_set
+        }
+
+        valid_atom_ids: set[int] = set()
+        for polymer in filtered_polymer.values():
+            for residue in polymer["residues"].values():
+                valid_atom_ids.update(int(a) for a in residue["atoms"])
+        for entity in filtered_non_polymer.values():
+            valid_atom_ids.update(int(a) for a in entity.get("atoms", {}))
+        for entity in filtered_water.values():
+            valid_atom_ids.update(int(a) for a in entity.get("atoms", {}))
+        for entity in filtered_branched.values():
+            valid_atom_ids.update(int(a) for a in entity.get("atoms", {}))
+
+        filtered_connections = []
+        for row in model.get("connections", []):
+            if row[0] not in valid_atom_ids:
+                continue
+            targets = [t for t in row[1:] if t in valid_atom_ids]
+            if targets:
+                filtered_connections.append([row[0], *targets])
+
+        filtered_model = {
+            "polymer": filtered_polymer,
+            "non_polymer": filtered_non_polymer,
+            "water": filtered_water,
+            "branched": filtered_branched,
+            "connections": filtered_connections,
+        }
+        filtered_data = {**self.data, "models": [filtered_model]}
+
+        with api_client() as client:
+            payload = {
+                "name": f"{self.name} (chains {','.join(chains)})",
+                "protein_data": filtered_data,
+                "ancestor_uuid": self.uuid,
+            }
+            response = client.post("/protein", json=payload)
+            response.raise_for_status()
+            return Protein(**response.json())
+
     def refresh(self, in_place: bool = True) -> Self:
         """
         Loads protein data
@@ -323,7 +403,6 @@ def upload_protein(
         # Step 1: Read the file and post it to the conversion endpoint.
         conversion_payload = {"name": name, "text": file_path.read_text()}
         conversion_response = client.post("/convert/pdb_file_to_protein", json=conversion_payload)
-        conversion_response.raise_for_status()  # Ensure the request was successful
 
         # Extract the JSON data from the conversion response.
         protein_data = conversion_response.json()
@@ -335,20 +414,19 @@ def upload_protein(
             "project_uuid": project_uuid,
         }
         final_response = client.post("/protein", json=creation_payload)
-        final_response.raise_for_status()
 
         # Deserialize the final JSON response into a Protein object and return it.
         return Protein(**final_response.json())
 
 
 def create_protein_from_pdb_id(
-    name: str, code: str, project_uuid: str | Project | None = None
+    code: str, name: str | None = None, project_uuid: str | Project | None = None
 ) -> Protein:
     """
     Creates a protein from a PDB ID.
 
-    :param name: Name of the protein to create
     :param code: PDB ID of the protein to create
+    :param name: Name of the protein. Defaults to the PDB ID.
     :param project_uuid: UUID of the project to create the protein in
     :returns: Protein object representing the created protein
     :raises requests.HTTPError: if the request to the API fails
@@ -356,21 +434,22 @@ def create_protein_from_pdb_id(
     if isinstance(project_uuid, Project):
         project_uuid = project_uuid.uuid
     with api_client() as client:
-        # Step 1: Read the file and post it to the conversion endpoint.
         conversion_response = client.post(f"/convert/pdb_id_to_protein?pdb_id={code}")
-        conversion_response.raise_for_status()  # Ensure the request was successful
-
-        # Extract the JSON data from the conversion response.
         protein_data = conversion_response.json()
 
-        # Step 2: Use the converted data to create the final protein object.
         creation_payload = {
-            "name": name,
+            "name": name or code,
             "protein_data": protein_data,
             "project_uuid": project_uuid,
         }
         final_response = client.post("/protein", json=creation_payload)
-        final_response.raise_for_status()
 
-        # Deserialize the final JSON response into a Protein object and return it.
-        return Protein(**final_response.json())
+    protein = Protein(**final_response.json())
+    chains = protein.chains
+    if len(chains) > 1:
+        warnings.warn(
+            f"{code} has multiple chains {chains}. Select one with "
+            f"protein.select_chains(['{chains[0]}']).",
+            stacklevel=2,
+        )
+    return protein

rowan/utils.py

@@ -52,13 +52,33 @@ def smiles_to_stjames(smiles: str) -> stjames.Molecule:
     return stjames.Molecule.from_smiles(smiles)
 
 
+def _raise_for_status(response: httpx.Response) -> None:
+    """Response hook that raises HTTPStatusError with the API's detail message if available."""
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError as e:
+        try:
+            response.read()
+            detail = response.json().get("detail")
+        except Exception:
+            detail = None
+        if detail:
+            raise httpx.HTTPStatusError(
+                f"{e.response.status_code} {detail}",
+                request=e.request,
+                response=e.response,
+            ) from None
+        raise
+
+
 @contextmanager
 def api_client() -> Generator[httpx.Client, None, None]:
     """Wraps `httpx.Client` with Rowan-specific kwargs."""
     with httpx.Client(
         base_url=API_URL,
         headers={"X-API-Key": get_api_key()},
-        timeout=30,
+        timeout=120,
+        event_hooks={"response": [_raise_for_status]},
     ) as client:
         yield client
 

rowan/workflows/__init__.py

@@ -47,6 +47,11 @@ 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 .descriptors import DescriptorsResult, submit_descriptors_workflow
 from .docking import DockingResult, DockingScore, submit_docking_workflow

rowan/workflows/base.py

@@ -9,14 +9,16 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, ClassVar, Self
 
+import httpx
 import stjames
 from pydantic import BaseModel, ConfigDict, Field, ValidationError
 from rdkit import Chem
 
 from ..folder import Folder
 from ..molecule import Molecule as RowanMolecule
+from ..project import default_project, retrieve_project
 from ..types import SMILES, StructureInput
-from ..utils import api_client
+from ..utils import api_client, get_project_uuid
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -648,6 +650,9 @@ def molecule_to_dict(mol: StructureInput | dict[str, Any]) -> dict[str, Any]:
             raise TypeError(f"Cannot convert {type(mol)} to molecule dict")
 
 
+_FEATURE_GATE_DETAIL = "You do not have access to this feature."
+
+
 def submit_workflow(
     workflow_type: stjames.WORKFLOW_NAME,
     workflow_data: dict[str, Any] | None = None,
@@ -700,8 +705,16 @@ def submit_workflow(
         raise ValueError("You must provide either `initial_smiles` or a valid `initial_molecule`.")
 
     with api_client() as client:
-        response = client.post("/workflow", json=data)
-        response.raise_for_status()
+        try:
+            response = client.post("/workflow", json=data)
+        except httpx.HTTPStatusError as e:
+            if _FEATURE_GATE_DETAIL in str(e):
+                raise PermissionError(
+                    f"{e} Visit https://labs.rowansci.com/account/settings to upgrade your account"
+                    " or contact us for access. Call rowan.whoami() to see your current"
+                    " .enabled_workflows and .feature_list."
+                ) from None
+            raise
         return Workflow(**response.json())
 
 
@@ -792,6 +805,12 @@ def list_workflows(
     :returns: List of Workflow objects that match the search criteria.
     :raises requests.HTTPError: if the request to the API fails.
     """
+    if parent_uuid is None:
+        if project_uuid := get_project_uuid():
+            parent_uuid = retrieve_project(project_uuid).root_folder_uuid
+        else:
+            parent_uuid = default_project().root_folder_uuid
+
     params: dict[str, Any] = {"page": page, "size": size}
 
     if parent_uuid is not None:

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:
     """
@@ -271,7 +319,7 @@ def submit_basic_calculation_workflow(
     workflow = stjames.BasicCalculationWorkflow(
         initial_molecule=mol_dict,
         settings=settings,
-        tasks=settings.tasks,
+        tasks=tasks,
         engine=settings.engine,
     )
 

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/docking.py

@@ -192,12 +192,12 @@ def submit_docking_workflow(
     if isinstance(protein, Protein):
         protein = protein.uuid
 
-    docking_settings = {
-        "executable": executable,
-        "exhaustiveness": exhaustiveness,
-        "max_poses": max_poses,
-        "scoring_function": scoring_function,
-    }
+    docking_settings = stjames.VinaSettings(
+        executable=executable,
+        exhaustiveness=exhaustiveness,
+        max_poses=max_poses,
+        scoring_function=scoring_function,
+    )
 
     workflow = stjames.DockingWorkflow(
         initial_molecule=mol_dict,
@@ -209,9 +209,12 @@ def submit_docking_workflow(
         docking_settings=docking_settings,
     )
 
+    workflow_data = workflow.model_dump(serialize_as_any=True, mode="json")
+    workflow_data["docking_settings"].setdefault("settings_type", "vina")
+
     data = {
         "workflow_type": "docking",
-        "workflow_data": workflow.model_dump(serialize_as_any=True, mode="json"),
+        "workflow_data": workflow_data,
         "initial_molecule": mol_dict,
         "name": name,
         "folder_uuid": folder_uuid,

rowan/workflows/fukui.py

@@ -68,9 +68,8 @@ def submit_fukui_workflow(
 
         - ``"solvent"``: solvent name string (e.g. ``"water"``, ``"dichloromethane"``,
           ``"dmso"``). See ``rowan.Solvent`` for all valid values.
-        - ``"model"``: solvation model. Use ``"alpb"`` or ``"gbsa"`` for xTB methods
-          (the defaults ``gfn1_xtb`` / ``gfn2_xtb``); use ``"cpcm"`` or ``"smd"`` for
-          DFT methods.
+        - ``"model"``: solvation model (e.g. ``"alpb"``, ``"gbsa"``, ``"cpcmx"`` for xTB;
+          ``"cpcm"``, ``"pcm"`` for DFT). Must be compatible with the engine for the chosen method.
 
         Example: ``solvent_settings={"solvent": "water", "model": "alpb"}``
     :param name: Name of the workflow.
@@ -80,7 +79,6 @@ def submit_fukui_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 the solvent model is incompatible with the chosen method.
     :raises requests.HTTPError: if the request to the API fails.
     """
     require_coordinates(initial_molecule)
@@ -88,21 +86,6 @@ def submit_fukui_workflow(
         raise ValueError("Provide either `folder` or `folder_uuid`, not both.")
     if folder:
         folder_uuid = folder.uuid
-    if solvent_settings is not None:
-        model = solvent_settings.get("model")
-        is_xtb = stjames.Method(fukui_method) in stjames.XTB_METHODS
-        xtb_models = {"alpb", "gbsa"}
-        dft_models = {"pcm", "cpcm", "cosmo", "cpcmx", "smd"}
-        if is_xtb and model not in xtb_models:
-            raise ValueError(
-                f"xTB Fukui methods require 'alpb' or 'gbsa' solvation model, got '{model}'"
-            )
-        if not is_xtb and model not in dft_models:
-            raise ValueError(
-                f"DFT Fukui methods require 'cpcm', 'smd', 'pcm', 'cosmo', or 'cpcmx' "
-                f"solvation model, got '{model}'"
-            )
-
     mol_dict = molecule_to_dict(initial_molecule)
 
     optimization_settings = stjames.Settings(method=optimization_method)

rowan/workflows/msa.py

@@ -25,7 +25,7 @@ class MSAResult(WorkflowResult):
     def _output_formats(self) -> list[str]:
         """Output formats requested for the MSA."""
         fmts = getattr(self._workflow, "output_formats", []) or []
-        return [f.value if hasattr(f, "value") else str(f) for f in fmts]
+        return [f.value for f in fmts]
 
     def download_files(
         self,
@@ -41,17 +41,16 @@ class MSAResult(WorkflowResult):
         :raises ValueError: If the requested format wasn't in the original output_formats.
         :raises HTTPError: If the API request fails.
         """
-        if format is not None and format not in self._output_formats:
+        fmt_str: str | None = format.value if isinstance(format, stjames.MSAFormat) else format
+        if fmt_str is not None and fmt_str not in self._output_formats:
             raise ValueError(
-                f"Format '{format}' was not requested. Available formats: {self._output_formats}"
+                f"Format '{fmt_str}' was not requested. Available formats: {self._output_formats}"
             )
 
         path = Path(path) if path is not None else Path.cwd()
-
         path.mkdir(parents=True, exist_ok=True)
 
-        fmt_str: str = format.value if isinstance(format, stjames.MSAFormat) else format  # type: ignore[assignment]
-        formats_to_download = [fmt_str] if format is not None else self._output_formats
+        formats_to_download = [fmt_str] if fmt_str is not None else self._output_formats
         downloaded_paths = []
 
         for fmt in formats_to_download:
@@ -84,8 +83,7 @@ def submit_msa_workflow(
     Submits a Multiple Sequence Alignment (MSA) workflow to the API.
 
     :param initial_protein_sequences: List of protein sequences to align (amino acid strings).
-    :param output_formats: Output formats for the MSA files ("colabfold", "chai", "boltz").
-        Defaults to {"colabfold"}.
+    :param output_formats: Output formats for the MSA files. Defaults to {MSAFormat.COLABFOLD}.
     :param name: Name to assign to the workflow.
     :param folder_uuid: UUID of the folder where the workflow will be stored.
     :param folder: Folder object to store the workflow in.
@@ -102,20 +100,15 @@ def submit_msa_workflow(
     if output_formats is None:
         output_formats = {"colabfold"}
 
-    # Convert to stjames types
-    protein_sequences = []
-    for seq in initial_protein_sequences:
-        if isinstance(seq, stjames.ProteinSequence):
-            protein_sequences.append(seq)
-        else:
-            protein_sequences.append(stjames.ProteinSequence(sequence=seq))
-
-    msa_formats = []
-    for fmt in output_formats:
-        if isinstance(fmt, stjames.MSAFormat):
-            msa_formats.append(fmt)
-        else:
-            msa_formats.append(stjames.MSAFormat(fmt))
+    protein_sequences = [
+        seq if isinstance(seq, stjames.ProteinSequence) else stjames.ProteinSequence(sequence=seq)
+        for seq in initial_protein_sequences
+    ]
+
+    msa_formats = [
+        fmt if isinstance(fmt, stjames.MSAFormat) else stjames.MSAFormat(fmt)
+        for fmt in output_formats
+    ]
 
     workflow = stjames.MSAWorkflow(
         initial_protein_sequences=protein_sequences,

rowan/workflows/pka.py

@@ -43,10 +43,9 @@ class pKaMicrostate:
     uncertainty: float | None = None
 
 
-# Methods grouped by input type and solvent support
+# Methods grouped by input type
 _PKA_3D_METHODS = {"aimnet2_wagen2024", "gxtb_wagen2026"}
 _PKA_SMILES_METHODS = {"chemprop_nevolianis2025", "starling"}
-_PKA_WATER_ONLY_METHODS = {"aimnet2_wagen2024", "gxtb_wagen2026", "starling"}
 
 
 @register_result("pka")
@@ -163,7 +162,7 @@ def submit_pka_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 method and input type don't match, or solvent is unsupported.
+    :raises ValueError: If method/input type mismatch, or chemprop used with protonate_elements.
     :raises requests.HTTPError: if the request to the API fails.
     """
     if folder and folder_uuid:
@@ -187,9 +186,6 @@ def submit_pka_workflow(
         raise ValueError(
             f"{method} requires a SMILES string. Provide a SMILES string, not a 3D structure."
         )
-    if method in _PKA_WATER_ONLY_METHODS and solvent != "water":
-        raise ValueError(f"{method} only supports water as solvent.")
-
     if method == "chemprop_nevolianis2025" and protonate_elements:
         raise ValueError(
             "chemprop_nevolianis2025 was only trained on deprotonation 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_md.py

@@ -101,6 +101,28 @@ class ProteinMDResult(WorkflowResult):
         """Any messages or warnings from the workflow."""
         return parse_messages(getattr(self._workflow, "messages", None))
 
+    def get_atom_distances(
+        self,
+        atom_pairs: list[tuple[int, int]],
+        replicate: int = 0,
+    ) -> list[list[float]]:
+        """
+        Fetch interatomic distances over the trajectory for specified atom pairs.
+
+        :param atom_pairs: List of (atom_i, atom_j) index pairs (0-indexed).
+        :param replicate: Trajectory replicate index (default 0).
+        :returns: List of distance arrays, one per pair, over all frames (Angstrom).
+        :raises HTTPError: If the API request fails.
+        """
+        with api_client() as client:
+            response = client.post(
+                f"/trajectory/{self.workflow_uuid}/atom_trajectories",
+                params={"replicate": replicate},
+                json=atom_pairs,
+            )
+            response.raise_for_status()
+        return response.json()
+
     def download_trajectories(
         self,
         replicates: list[int],

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.3.dist-info → rowan_python-3.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rowan-python
-Version: 3.1.3
+Version: 3.1.5
 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.217
 Description-Content-Type: text/markdown
 
 # Rowan Python Library

{rowan_python-3.1.3.dist-info → rowan_python-3.1.5.dist-info}/RECORD

@@ -1,46 +1,47 @@
-rowan/__init__.py,sha256=UhyjCkQh7YDTtemmetfelGD1d36WSJ6oaWct7CP2eyQ,1331
+rowan/__init__.py,sha256=ui5-72WoXjhvvKU3XqOZAvaz-BXkDT13z1m62fISsvg,1553
 rowan/api_keys.py,sha256=TvG5l5MmQ3Qt8Z3Y7jCA_lcrwEHuI7xHy-KLbIdQ8_A,4793
-rowan/calculation.py,sha256=lZZ52DxPsuJWCTzFZXjhauHK6dV0KCUwzoxtmoxSY48,3442
+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=eyKdZjHR-LsNK0yS8iedb0vPi3OB10gluuA1-Ee_JCg,9202
-rowan/molecule.py,sha256=LyneBgSbNS7ByQ2sI8hcRLOXwljZMZQtALgAYcqX2tM,10844
+rowan/folder.py,sha256=RRg68dObluJ2RCTKX3rb7RxziOXOQUYxkfQSU2R5VMk,13708
+rowan/molecule.py,sha256=1l-3YCN_A75Uz_Q-dMWuhkeF8rhD1z2JQM7AENyjKYM,15512
 rowan/project.py,sha256=RtxYE9jv3Yz6fH5I56iDGRG5EbwlOHiSK-HF1uxc0d4,4582
-rowan/protein.py,sha256=hfDqk_LgU8o39Zg2kHHWf8EqPcQOnT3Mo43Ik1gAO68,14856
+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=c1s6Ze-OqLtfvrD23OV60otskejmj-CD88nNf8_nFcw,3636
-rowan/workflows/__init__.py,sha256=ohl2q-Nqgs4E9cl5KIGigQgE2ifiTmY5dib5R_qNxO4,4510
+rowan/utils.py,sha256=DBphY1he8Vl3RNf6CbLp5BSX9RG5EfHzhMs-9TmcE_g,4299
+rowan/workflows/__init__.py,sha256=qQZrfkB0f8B82WyNP6a9YeP6I3Cmfans9HvqD2amw28,4635
 rowan/workflows/admet.py,sha256=jDx1Kkgmp0XaeojPzaCFY_yUwvqtSM7Cezps-93cqPw,2865
 rowan/workflows/analogue_docking.py,sha256=IxVaYD8ITsLFfvZ6N7v4KmvIS25DcUQkv-_tMhEfG_4,9707
-rowan/workflows/base.py,sha256=UI5KoraDCR9GX1eRBMEYCEb3mV737xP_5T0M_gfGqag,32176
-rowan/workflows/basic_calculation.py,sha256=nAQGwpZnlR9Bi_p4U79_NO6IbcY3gOXQxMpubNHB9AY,11249
+rowan/workflows/base.py,sha256=k858otXLuorw4MZ1hvqZI_m0n_38htC7Hy3OMCX1TOA,32961
+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/descriptors.py,sha256=QjjpzPDpAO_EhPOK--gle6sGpVHMpdAs_yrvC0oiseY,3092
-rowan/workflows/docking.py,sha256=iEljm5N9A9fJrqpX2_0YznGpN9z3__UDvYoP-5t8n3c,7914
+rowan/workflows/docking.py,sha256=VTauRB6knysUsAzGhEhI95F6BQLAuZbNEA468wByohc,8031
 rowan/workflows/double_ended_ts_search.py,sha256=eZNEXhfh5W5j5JcEzKnKMMf9HPbIM6HDLnzoh_vVFXk,8115
 rowan/workflows/electronic_properties.py,sha256=MXbsI4OHyXWt3f4Qc5g7-SNjyyEoYzocWVdcP1H06sY,8436
-rowan/workflows/fukui.py,sha256=MKfjbPkZ7EBQhDf0R4o79Np4ZuRPshhJJnqW6kQmF4o,5171
+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/macropka.py,sha256=IxGwr9LziIwj_x6pXEhJN6SywS_KULziuYoETNqM370,5684
 rowan/workflows/membrane_permeability.py,sha256=wHZ1IPlXwBB343uVAm7EuhedcMPd-Uy4jMqHfXRHwqY,4680
-rowan/workflows/msa.py,sha256=V3B1SyWPR8MT306hh9W-T9JTpi_E-XgAIeF9yRQZ7tI,5075
+rowan/workflows/msa.py,sha256=k_FlxxtdgvmxDN3LyLDEQeFfI8_lyBJz1KFtz3S4oNo,4816
 rowan/workflows/multistage_optimization.py,sha256=04kZPC3SmVOxqEQOwyBrS3DlelM-b8e531T_LuVt3tU,7385
 rowan/workflows/nmr.py,sha256=68be_Xgiy1AykGdIL4fR1pqKllD1nLm3IidsStzKtz4,5521
-rowan/workflows/pka.py,sha256=xQPaOHxPQqCY_zi97LW9brpXPn3xjyeF9RDE1Rz8HQk,8772
+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_md.py,sha256=41S-GIHP91ahW5mIVxjAkpZbxept98IgausM5JoeckA,9276
-rowan/workflows/rbfe_graph.py,sha256=7UJA3ZBbvtaB9l1KQi9279Pc89moVnBHO-XJpxEr5uQ,7238
+rowan/workflows/protein_md.py,sha256=zqKEtL514uchgbxsyO4vhokzTU-X4lTFA1BM5O8HvTU,10117
+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 +50,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.3.dist-info/METADATA,sha256=mv9y4fxN9Ds7WCnd2W-vZL-LdLCNkp_1XxWipE5Q2Yg,2052
-rowan_python-3.1.3.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-rowan_python-3.1.3.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
-rowan_python-3.1.3.dist-info/RECORD,,
+rowan_python-3.1.5.dist-info/METADATA,sha256=g-Ttz5kgCuMcbHCBKoHlsBOJJLEvEdcTtornkx9eIQA,2052
+rowan_python-3.1.5.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+rowan_python-3.1.5.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
+rowan_python-3.1.5.dist-info/RECORD,,