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

rowan/__init__.py

@@ -12,8 +12,11 @@ from stjames import (
     ConformerClusteringSettings,
     ConformerGenSettingsUnion,
     Correction,
+    CovalentInhibitorScanSettings,
+    DockingSettings,
     Engine,
     ETKDGSettings,
+    GninaSettings,
     GreedyClusteringSettings,
     iMTDSettings,
     KMeansClusteringSettings,
@@ -33,6 +36,7 @@ from stjames import (
     SinglePointEnergySettings,
     Task,
     VibrationalMode,
+    VinaSettings,
 )
 from stjames.workflows.relative_binding_free_energy_perturbation import RBFEGraph, RBFEGraphEdge
 from stjames.excited_state_settings import TDDFTSettings
@@ -44,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/protein.py

@@ -400,22 +400,20 @@ def upload_protein(
     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_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()
 
-        # 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,
             "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())
 
 

rowan/test_utils.py

@@ -0,0 +1,54 @@
+"""Tests for Rowan request utilities."""
+
+import asyncio
+
+from pytest import MonkeyPatch, raises
+
+import rowan
+from rowan.utils import api_credentials, get_api_key, get_project_uuid
+
+
+def test_api_credentials_override_global_configuration(monkeypatch: MonkeyPatch) -> None:
+    """Prefer context-local credentials without changing global configuration."""
+    monkeypatch.setattr(rowan, "api_key", "global-key")
+    monkeypatch.setattr(rowan, "project_uuid", "global-project")
+    monkeypatch.setenv("ROWAN_API_KEY", "environment-key")
+
+    with api_credentials("context-key", project_uuid="context-project"):
+        assert get_api_key() == "context-key"
+        assert get_project_uuid() == "context-project"
+
+    assert get_api_key() == "global-key"
+    assert get_project_uuid() == "global-project"
+
+
+def test_api_credentials_restore_nested_context() -> None:
+    """Restore outer credentials after a nested context exits."""
+    with api_credentials("outer-key", project_uuid="outer-project"):
+        with api_credentials("inner-key"):
+            assert get_api_key() == "inner-key"
+            assert get_project_uuid() is None
+
+        assert get_api_key() == "outer-key"
+        assert get_project_uuid() == "outer-project"
+
+
+def test_api_credentials_isolate_async_tasks() -> None:
+    """Keep credentials isolated across concurrent asynchronous tasks."""
+
+    async def read_after_yield(api_key: str) -> str:
+        with api_credentials(api_key):
+            await asyncio.sleep(0)
+            return get_api_key()
+
+    async def run_workers() -> list[str]:
+        return list(await asyncio.gather(read_after_yield("first"), read_after_yield("second")))
+
+    assert asyncio.run(run_workers()) == ["first", "second"]
+
+
+def test_api_credentials_reject_empty_key() -> None:
+    """Reject empty context-local API keys."""
+    with raises(ValueError, match="cannot be empty"):
+        with api_credentials(""):
+            pass

rowan/utils.py

@@ -1,5 +1,7 @@
 import os
 from contextlib import contextmanager
+from contextvars import ContextVar
+from dataclasses import dataclass
 from typing import Generator
 
 import httpx
@@ -10,6 +12,40 @@ import rowan
 from .constants import API_URL
 
 
+@dataclass(frozen=True, slots=True)
+class _APIContext:
+    """Store credentials isolated to the current execution context."""
+
+    api_key: str
+    project_uuid: str | None
+
+
+_api_context: ContextVar[_APIContext | None] = ContextVar("rowan_api_context", default=None)
+
+
+@contextmanager
+def api_credentials(api_key: str, project_uuid: str | None = None) -> Generator[None, None, None]:
+    """Temporarily use Rowan credentials in the current execution context.
+
+    Context-local credentials take precedence over module-level and environment configuration.
+    Nested contexts restore the previous credentials when they exit, and concurrent threads or
+    asynchronous tasks remain isolated from one another.
+
+    :param api_key: Rowan API key
+    :param project_uuid: active project UUID, if any
+    :yields: control while the credentials are active
+    :raises ValueError: API key is empty
+    """
+    if not api_key:
+        raise ValueError("API key cannot be empty.")
+
+    token = _api_context.set(_APIContext(api_key=api_key, project_uuid=project_uuid))
+    try:
+        yield
+    finally:
+        _api_context.reset(token)
+
+
 def get_api_key() -> str:
     """
     Get the API key from the environment variable ROWAN_API_KEY or the module-level attribute
@@ -19,6 +55,8 @@ def get_api_key() -> str:
 
     :returns: API key.
     """
+    if (context := _api_context.get()) is not None:
+        return context.api_key
     if hasattr(rowan, "api_key") and rowan.api_key:
         return rowan.api_key
     elif (api_key := os.environ.get("ROWAN_API_KEY")) is not None:
@@ -36,6 +74,8 @@ def get_project_uuid() -> str | None:
 
     :returns: Project UUID string, or None if not set.
     """
+    if (context := _api_context.get()) is not None:
+        return context.project_uuid
     if hasattr(rowan, "project_uuid") and rowan.project_uuid:
         return rowan.project_uuid
     return None

rowan/workflows/__init__.py

@@ -53,6 +53,11 @@ from .binding_affinity import (
     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/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/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_python-3.1.5.dist-info → rowan_python-3.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rowan-python
-Version: 3.1.5
+Version: 3.1.7
 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.217
+Requires-Dist: stjames>=0.0.228
 Description-Content-Type: text/markdown
 
 # Rowan Python Library
@@ -30,9 +30,27 @@ The documentation is available [here](https://docs.rowansci.com/python-api).
 
 ## Agent skill
 
-Ships with a [skill](skills/computational-chemistry-and-biology/) that makes it easy for coding agents to use Rowan's tools to power chemistry and biology tasks. To use it, copy the directory into your agent's skills folder.
+Ships with a [computational chemistry and biology skill](skills/computational-chemistry-and-biology/)
+that helps coding agents choose and run Rowan workflows through either Rowan MCP tools or the
+Rowan Python SDK.
 
-Download the latest skill as a zip [here](https://github.com/rowansci/rowan-python/releases/download/skill-latest/computational-chemistry-and-biology-skill.zip), then unzip it into your agent's skills folder.
+### Claude Code
+
+```bash
+claude plugin marketplace add https://github.com/rowansci/rowan-python.git
+claude plugin install computational-chemistry-and-biology@rowan
+```
+
+### Codex
+
+```bash
+codex plugin marketplace add rowansci/rowan-python --ref master
+codex plugin add computational-chemistry-and-biology@rowan
+```
+
+Start a new Claude Code or Codex session after installation. For manual installation, download the
+[latest skill ZIP](https://github.com/rowansci/rowan-python/releases/download/skill-latest/computational-chemistry-and-biology-skill.zip)
+and extract it into your agent's skills directory.
 
 ## Running examples
 

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

@@ -1,4 +1,4 @@
-rowan/__init__.py,sha256=ui5-72WoXjhvvKU3XqOZAvaz-BXkDT13z1m62fISsvg,1553
+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
@@ -6,14 +6,15 @@ rowan/constants.py,sha256=emCH4m9OL2Hm5E-6mJGM_FgzrK_JrZT-FiKJ6pMNQ4Y,84
 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=T2JAqfncP80yV5gEWYA-TlpNY3WeWaNHPE0Xg5voU24,17968
+rowan/protein.py,sha256=uFMF2BXgIvn6KOw3cdE-LDvZPPbjAxqqwgxakLd85XA,17763
 rowan/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rowan/test_utils.py,sha256=DTuZqftx6ycIatajAxSGWgDaGglLvTw2TYnVJHiiNdo,1936
 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=qQZrfkB0f8B82WyNP6a9YeP6I3Cmfans9HvqD2amw28,4635
+rowan/utils.py,sha256=J-3o9_ZlOrl4_ZuuC1yjEOPdD1IkKO0BOXBncV3Ij7c,5670
+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=EovymT6fV6mxmt4G4kRtiskSPGB7w7KAHqBaGtgQI2Q,12941
 rowan/workflows/batch_docking.py,sha256=ePnb1hcsmnUfffl1-k9HNkOC09RjY9bZS9XcqAGNeFs,3621
@@ -21,15 +22,16 @@ 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
@@ -39,7 +41,7 @@ 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=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=0eMfvwtQhyajUC8T-bhdcYNKi6Pkja6x6dHjCnEwxPw,8081
 rowan/workflows/redox_potential.py,sha256=bBeT1K9XGVpjCFZeeuv7Vtr3EYHN2okJ4LqYc3gMV04,5427
@@ -50,7 +52,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.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,,
+rowan_python-3.1.7.dist-info/METADATA,sha256=mCUORIhOBiBBn69iu-_EXm3QUnUuv6wwDKKK84cio3o,2436
+rowan_python-3.1.7.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+rowan_python-3.1.7.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
+rowan_python-3.1.7.dist-info/RECORD,,

{rowan_python-3.1.5.dist-info → rowan_python-3.1.7.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