rowan-python 3.0.7__py3-none-any.whl → 3.0.9__py3-none-any.whl

rowan/__init__.py

@@ -29,6 +29,7 @@ from stjames.optimization.freezing_string_method import (
 api_key: str | None = None
 project_uuid: str | None = None
 
+from .api_keys import *
 from .calculation import *
 from .folder import *
 from .molecule import *

rowan/api_keys.py

@@ -0,0 +1,144 @@
+import uuid
+from datetime import datetime
+from typing import Literal, Self
+
+from pydantic import BaseModel
+
+from .utils import api_client
+
+APIKeyScope = Literal["read", "read_write", "read_write_delete"]
+
+
+class APIKey(BaseModel):
+    """
+    Rowan API key.
+
+    :ivar uuid: UUID of the API key.
+    :ivar name: Human-readable name of the API key.
+    :ivar created_at: When the key was created.
+    :ivar expires_at: When the key expires.
+    :ivar is_expired: Whether the key has expired.
+    :ivar is_revoked: Whether the key has been revoked.
+    :ivar scope: Permission scope ("read", "read_write", or "read_write_delete").
+    :ivar can_manage_api_keys: Whether this key can create/list/revoke other API keys.
+    :ivar scoped_project_uuid: If set, the key can only access this project.
+    :ivar created_by_key_uuid: UUID of the API key used to create this one (if any).
+    :ivar revoked_at: When the key was revoked, if applicable.
+    :ivar last_used_at: When the key was last used, if known.
+    """
+
+    uuid: str
+    name: str
+    created_at: datetime
+    expires_at: datetime
+    is_expired: bool
+    is_revoked: bool
+    scope: str
+    can_manage_api_keys: bool
+    scoped_project_uuid: str | None = None
+    created_by_key_uuid: str | None = None
+    revoked_at: datetime | None = None
+    last_used_at: datetime | None = None
+
+    def __repr__(self) -> str:
+        return (
+            f"<APIKey name='{self.name}' scope='{self.scope}' "
+            f"scoped_project_uuid={self.scoped_project_uuid!r} uuid='{self.uuid}'>"
+        )
+
+    def revoke(self) -> Self:
+        """
+        Revoke this API key.
+
+        :returns: Updated APIKey object.
+        """
+        with api_client() as client:
+            response = client.post(f"/api_key/{self.uuid}/revoke")
+            response.raise_for_status()
+            return type(self)(**response.json())
+
+
+class CreatedAPIKey(BaseModel):
+    """
+    Result of creating a new API key.
+
+    The plaintext ``key`` is only available at creation time — store it now,
+    it cannot be retrieved later.
+
+    :ivar key: Plaintext API key. Save this; it is only returned once.
+    :ivar api_key: Metadata for the newly-created key.
+    """
+
+    key: str
+    api_key: APIKey
+
+
+def create_api_key(
+    name: str = "api-key",
+    scope: APIKeyScope = "read_write",
+    valid_days: int = 365,
+    scoped_project_uuid: str | None = None,
+) -> CreatedAPIKey:
+    """
+    Create a new API key.
+
+    The caller must currently authenticate with an unscoped key that has
+    ``can_manage_api_keys`` permission.
+
+    :param name: Human-readable name for the key.
+    :param scope: Permission scope. One of "read", "read_write", "read_write_delete".
+    :param valid_days: Number of days until the key expires.
+    :param scoped_project_uuid: If provided, restrict the key to a single project.
+    :returns: plaintext key together with its metadata; the plaintext key is
+        only returned once — store it immediately.
+    """
+    plaintext_key = f"rowan-sk{uuid.uuid4()}"
+    payload = {
+        "api_key": plaintext_key,
+        "name": name,
+        "scope": scope,
+        "valid_days": valid_days,
+        "scoped_project_uuid": scoped_project_uuid,
+    }
+    with api_client() as client:
+        response = client.post("/api_key", json=payload)
+        if response.status_code == 403:
+            raise PermissionError(
+                "API key creation rejected by the server (403). The key you are "
+                "authenticating with must be unscoped and have `can_manage_api_keys` "
+                "permission. Create a manager key from the Rowan web UI "
+                "(Account → API keys) and retry with that key."
+            )
+        response.raise_for_status()
+        return CreatedAPIKey(key=plaintext_key, api_key=APIKey(**response.json()))
+
+
+def list_api_keys(active: bool | None = True) -> list[APIKey]:
+    """
+    List API keys belonging to the current user.
+
+    :param active: If True (default), only return non-revoked, non-expired keys.
+        If False, only return revoked or expired keys. If None, return all keys.
+    :returns: List of APIKey objects.
+    """
+    params: dict[str, str] = {}
+    if active is not None:
+        params["active"] = "true" if active else "false"
+
+    with api_client() as client:
+        response = client.get("/api_key", params=params)
+        response.raise_for_status()
+        return [APIKey(**item) for item in response.json()]
+
+
+def revoke_api_key(uuid: str) -> APIKey:
+    """
+    Revoke an API key by UUID.
+
+    :param uuid: UUID of the key to revoke.
+    :returns: Updated APIKey object.
+    """
+    with api_client() as client:
+        response = client.post(f"/api_key/{uuid}/revoke")
+        response.raise_for_status()
+        return APIKey(**response.json())

rowan/workflows/__init__.py

@@ -92,7 +92,11 @@ from .protein_binder_design import (
     submit_protein_binder_design_workflow,
 )
 from .protein_cofolding import (
+    CofoldingModel,
     CofoldingResult,
+    ConstraintTarget,
+    ContactConstraint,
+    PocketConstraint,
     ProteinCofoldingResult,
     submit_protein_cofolding_workflow,
 )

rowan/workflows/base.py

@@ -25,6 +25,12 @@ logger.setLevel(logging.INFO)
 Mode = stjames.Mode
 Solvent = stjames.Solvent
 MessageType = stjames.MessageType
+Method = stjames.Method
+Task = stjames.Task
+Settings = stjames.Settings
+MultiStageOptSettings = stjames.MultiStageOptSettings
+ETKDGSettings = stjames.ETKDGSettings
+ConformerGenSettings = stjames.conformers.ConformerGenSettings
 
 
 @dataclass(frozen=True, slots=True)

rowan/workflows/bde.py

@@ -90,12 +90,14 @@ def submit_bde_workflow(
         folder_uuid = folder.uuid
     initial_molecule = molecule_to_dict(initial_molecule)
 
-    workflow = stjames.BDEWorkflow(
-        initial_molecule=initial_molecule,
-        mode=mode,
-        atoms=atoms or [],
-        all_CH=all_CH,
-        all_CX=all_CX,
+    workflow = stjames.BDEWorkflow.model_validate(
+        {
+            "initial_molecule": initial_molecule,
+            "mode": mode,
+            "atoms": atoms or [],
+            "all_CH": all_CH,
+            "all_CX": all_CX,
+        }
     )
 
     data = {

rowan/workflows/conformer_search.py

@@ -8,6 +8,13 @@ from ..molecule import Molecule
 from ..types import MoleculeInput, SolventInput
 from ..utils import api_client
 from .base import (
+    ConformerGenSettings,
+    ETKDGSettings,
+    Method,
+    Mode,
+    MultiStageOptSettings,
+    Settings,
+    Task,
     Workflow,
     WorkflowResult,
     molecule_to_dict,
@@ -114,12 +121,68 @@ class ConformerSearchResult(WorkflowResult):
         return self._cache[cache_key]
 
 
+_FINAL_METHOD_TO_MSO_RECIPE: dict[Method, tuple[Method, Method | None]] = {
+    Method.AIMNET2_WB97MD3: (Method.AIMNET2_WB97MD3, None),
+    Method.OMOL25_CONSERVING_S: (Method.OMOL25_CONSERVING_S, None),
+    Method.GFN2_XTB: (Method.GFN2_XTB, None),
+    Method.G_XTB: (Method.GFN2_XTB, Method.G_XTB),
+    Method.R2SCAN3C: (Method.GFN2_XTB, Method.R2SCAN3C),
+}
+
+
+def _mso_for_final_method(
+    final_method: Method,
+    solvent: SolventInput = None,
+    transition_state: bool = False,
+) -> MultiStageOptSettings:
+    """Build a `MultiStageOptSettings` for `final_method` matching tinbergen's
+    conformer-search MSO presets. Falls back to a single opt stage at
+    `final_method` for methods without a named preset.
+
+    `solvent` and `transition_state` are merged into each stage's `Settings`
+    when supplied; the named preset itself is independent of them (mirrors how
+    tinbergen's form keeps the preset dropdown separate from the solvent / TS
+    toggles).
+    """
+    opt_method, sp_method = _FINAL_METHOD_TO_MSO_RECIPE.get(final_method, (final_method, None))
+
+    def _solvent_settings_for(method: Method) -> dict | None:
+        if not solvent:
+            return None
+        return {
+            "solvent": solvent,
+            "model": "alpb" if method in stjames.XTB_METHODS else "cpcm",
+        }
+
+    opt_stage = Settings(
+        method=opt_method,
+        tasks=[Task.OPTIMIZE],
+        mode=Mode.AUTO,
+        solvent_settings=_solvent_settings_for(opt_method),
+        opt_settings={"transition_state": transition_state, "constraints": []},
+    )
+    sp_stage: Settings | None = None
+    if sp_method is not None:
+        sp_stage = Settings(
+            method=sp_method,
+            tasks=[Task.ENERGY],
+            mode=Mode.AUTO,
+            solvent_settings=_solvent_settings_for(sp_method),
+        )
+
+    return MultiStageOptSettings(
+        optimization_settings=[opt_stage],
+        singlepoint_settings=sp_stage,
+    )
+
+
 def submit_conformer_search_workflow(
     initial_molecule: MoleculeInput,
-    conf_gen_settings: stjames.ConformerGenSettings | None = None,
-    final_method: stjames.Method | str = "aimnet2_wb97md3",
+    conf_gen_settings: ConformerGenSettings | None = None,
+    final_method: Method | str = "aimnet2_wb97md3",
     solvent: SolventInput = None,
     transition_state: bool = False,
+    multistage_opt_settings: MultiStageOptSettings | None = None,
     name: str = "Conformer Search Workflow",
     folder_uuid: str | None = None,
     folder: Folder | None = None,
@@ -138,9 +201,16 @@ def submit_conformer_search_workflow(
         - ``LyrebirdSettings``  -- Rowan ML model
         - ``iMTDGCSettings``  -- CREST iMTD-GC metadynamics, more thorough
         - ``MonteCarloMultipleMinimumSettings``  -- MCMM conformer search
-    :param final_method: Method to use for the final optimization.
-    :param solvent: Solvent to use for the final optimization.
-    :param transition_state: Whether to optimize the transition state.
+    :param final_method: Method to use for the final optimization. Ignored if
+        `multistage_opt_settings` is provided.
+    :param solvent: Solvent to use for the final optimization. Ignored if
+        `multistage_opt_settings` is provided.
+    :param transition_state: Whether to optimize the transition state. Ignored
+        if `multistage_opt_settings` is provided.
+    :param multistage_opt_settings: Optimization stages and singlepoint settings
+        for ranking conformers. When provided, takes precedence over
+        `final_method` / `solvent` / `transition_state`. When omitted, an MSO is
+        built from those three params.
     :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.
@@ -155,34 +225,20 @@ def submit_conformer_search_workflow(
     if folder:
         folder_uuid = folder.uuid
     if conf_gen_settings is None:
-        conf_gen_settings = stjames.ETKDGSettings()
+        conf_gen_settings = ETKDGSettings()
 
     mol_dict = molecule_to_dict(initial_molecule)
 
-    if isinstance(final_method, str):
-        final_method = stjames.Method(final_method)
-
-    solvent_model = None
-    if solvent:
-        solvent_model = "alpb" if final_method in stjames.XTB_METHODS else "cpcm"
-
-    opt_settings = stjames.Settings(
-        method=final_method,
-        tasks=["optimize"],
-        mode=stjames.Mode.AUTO,
-        solvent_settings={"solvent": solvent, "model": solvent_model} if solvent else None,
-        opt_settings={"transition_state": transition_state, "constraints": []},
-    )
-
-    msos = stjames.MultiStageOptSettings(
-        mode=stjames.Mode.MANUAL,
-        xtb_preopt=True,
-        optimization_settings=[opt_settings],
-    )
+    if multistage_opt_settings is None:
+        if isinstance(final_method, str):
+            final_method = Method(final_method)
+        multistage_opt_settings = _mso_for_final_method(
+            final_method, solvent=solvent, transition_state=transition_state
+        )
 
     workflow = stjames.ConformerSearchWorkflow(
         initial_molecule=mol_dict,
-        multistage_opt_settings=msos,
+        multistage_opt_settings=multistage_opt_settings,
         conf_gen_settings=conf_gen_settings,
         solvent=solvent,
         transition_state=transition_state,

rowan/workflows/electronic_properties.py

@@ -2,7 +2,9 @@
 
 from dataclasses import dataclass
 
+import httpx
 import stjames
+from pydantic import ValidationError
 from stjames import ENGINE_METHODS, Engine, Method
 
 from ..folder import Folder
@@ -31,6 +33,22 @@ class ElectronicPropertiesResult(WorkflowResult):
 
     _stjames_class = stjames.ElectronicPropertiesWorkflow
 
+    def __post_init__(self) -> None:
+        # Computed results (dipole, charges, cubes, orbitals, ...) live only in
+        # the gzipped S3 blob, not in the workflow's object_data row. Fetch and
+        # parse it once on construction so accessors below see populated data.
+        super().__post_init__()
+        if not self.complete:
+            return
+        try:
+            with api_client() as client:
+                response = client.get(f"/orbitals/{self.workflow_uuid}/compressed_json")
+                response.raise_for_status()
+                populated = stjames.ElectronicPropertiesWorkflow.model_validate(response.json())
+            object.__setattr__(self, "_workflow", populated)
+        except (httpx.HTTPError, ValidationError):
+            pass
+
     def __repr__(self) -> str:
         return f"<ElectronicPropertiesResult dipole={self.dipole} D>"
 

rowan/workflows/multistage_optimization.py

@@ -1,14 +1,18 @@
 """Multistage optimization workflow - optimize molecules with staged methods."""
 
+from typing import Sequence
+
 import stjames
 
 from ..calculation import Calculation, retrieve_calculation
 from ..folder import Folder
 from ..molecule import Molecule
-from ..types import MoleculeInput, SolventInput
+from ..types import MoleculeInput
 from ..utils import api_client
 from .base import (
-    Mode,
+    Method,
+    Settings,
+    Task,
     Workflow,
     WorkflowResult,
     molecule_to_dict,
@@ -116,10 +120,8 @@ class MultiStageOptResult(WorkflowResult):
 
 def submit_multistage_optimization_workflow(
     initial_molecule: MoleculeInput,
-    mode: Mode = Mode.RAPID,
-    solvent: SolventInput = None,
-    xtb_preopt: bool = True,
-    transition_state: bool = False,
+    optimization_settings: Sequence[Settings] | None = None,
+    singlepoint_settings: Settings | None = None,
     frequencies: bool = False,
     name: str = "Multistage Optimization Workflow",
     folder_uuid: str | None = None,
@@ -131,12 +133,13 @@ def submit_multistage_optimization_workflow(
     """
     Submits a multistage-optimization workflow to the API.
 
+    Defaults to a 3-stage `r2scan_3c//gfn2_xtb//gfn_ff` stack.
+
     :param initial_molecule: Molecule to optimize.
-    :param mode: Mode to run the calculation in.
-    :param solvent: Solvent for the final single-point calculation.
-    :param xtb_preopt: Whether to pre-optimize with xTB.
-    :param transition_state: Whether this is a transition state optimization.
-    :param frequencies: Whether to calculate frequencies.
+    :param optimization_settings: Optimization stages to apply in order.
+    :param singlepoint_settings: Final singlepoint settings, applied after the
+        last optimization stage.
+    :param frequencies: Whether to calculate frequencies on the last optimization step.
     :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.
@@ -152,12 +155,18 @@ def submit_multistage_optimization_workflow(
         folder_uuid = folder.uuid
     mol_dict = molecule_to_dict(initial_molecule)
 
+    if optimization_settings is None:
+        optimization_settings = [
+            Settings(method=Method.GFN_FF, tasks=[Task.OPTIMIZE]),
+            Settings(method=Method.GFN2_XTB, tasks=[Task.OPTIMIZE]),
+        ]
+    if singlepoint_settings is None:
+        singlepoint_settings = Settings(method=Method.R2SCAN3C, tasks=[Task.ENERGY])
+
     workflow = stjames.MultiStageOptWorkflow(
         initial_molecule=mol_dict,
-        mode=mode,
-        solvent=solvent,
-        xtb_preopt=xtb_preopt,
-        transition_state=transition_state,
+        optimization_settings=optimization_settings or (),
+        singlepoint_settings=singlepoint_settings,
         frequencies=frequencies,
     )
 

rowan/workflows/protein_cofolding.py

@@ -9,8 +9,12 @@ from ..protein import Protein, retrieve_protein
 from ..utils import api_client
 from .base import Message, Workflow, WorkflowResult, parse_messages, register_result
 
-# Re-export cofolding model enum from stjames
 CofoldingModel = stjames.CofoldingModel
+# `ConstraintTarget` aliases stjames's `Token` - one position in an input
+# (a protein/nucleic-acid residue or a ligand atom) addressable by a constraint.
+ConstraintTarget = stjames.workflows.protein_cofolding.Token
+ContactConstraint = stjames.workflows.protein_cofolding.ContactConstraint
+PocketConstraint = stjames.workflows.protein_cofolding.PocketConstraint
 
 
 @dataclass(frozen=True, slots=True)
@@ -244,6 +248,9 @@ def submit_protein_cofolding_workflow(
     ligand_binding_affinity_index: int | None = None,
     use_msa_server: bool = True,
     use_potentials: bool = False,
+    contact_constraints: list[ContactConstraint] | None = None,
+    pocket_constraints: list[PocketConstraint] | None = None,
+    num_samples: int | None = None,
     compute_strain: bool = False,
     do_pose_refinement: bool = False,
     name: str = "Protein-Ligand Co-Folding",
@@ -260,6 +267,10 @@ def submit_protein_cofolding_workflow(
     Predicts the 3D structure of protein-protein, protein-ligand, protein-DNA,
     protein-RNA, or other biomolecular complexes.
 
+    See `examples/protein_cofolding_with_constraints.py` for a worked example
+    of using `ConstraintTarget`, `ContactConstraint`, and `PocketConstraint`
+    (Boltz-2 only).
+
     :param initial_protein_sequences: Protein sequences to be cofolded.
     :param initial_dna_sequences: DNA sequences to be cofolded.
     :param initial_rna_sequences: RNA sequences to be cofolded.
@@ -267,7 +278,10 @@ def submit_protein_cofolding_workflow(
     :param ligand_binding_affinity_index: Index of the ligand for which to compute
         the binding affinity.
     :param use_msa_server: Whether to use the MSA server for the computation.
-    :param use_potentials: Whether to use potentials for the computation.
+    :param use_potentials: Whether to use potentials (inference-time steering) with Boltz.
+    :param contact_constraints: Boltz contact constraints between two tokens.
+    :param pocket_constraints: Boltz pocket constraints between a binder and contact tokens.
+    :param num_samples: Number of diffusion samples to generate. If None, uses the model default.
     :param compute_strain: Whether to compute the strain of the pose
         (if `pose_refinement` is enabled).
     :param do_pose_refinement: Whether to optimize non-rotatable bonds in output poses.
@@ -302,6 +316,9 @@ def submit_protein_cofolding_workflow(
     workflow = stjames.ProteinCofoldingWorkflow(
         use_msa_server=use_msa_server,
         use_potentials=use_potentials,
+        contact_constraints=contact_constraints or [],
+        pocket_constraints=pocket_constraints or [],
+        num_samples=num_samples,
         model=model_str,
         ligand_binding_affinity_index=ligand_binding_affinity_index,
         initial_smiles_list=initial_smiles_list,

rowan/workflows/redox_potential.py

@@ -122,11 +122,13 @@ def submit_redox_potential_workflow(
         folder_uuid = folder.uuid
     initial_molecule = molecule_to_dict(initial_molecule)
 
-    workflow = stjames.RedoxPotentialWorkflow(
-        initial_molecule=initial_molecule,
-        oxidation=oxidation,
-        reduction=reduction,
-        mode=mode,
+    workflow = stjames.RedoxPotentialWorkflow.model_validate(
+        {
+            "initial_molecule": initial_molecule,
+            "oxidation": oxidation,
+            "reduction": reduction,
+            "mode": mode,
+        }
     )
 
     data = {

rowan/workflows/spin_states.py

@@ -7,11 +7,14 @@ import stjames
 
 from ..calculation import Calculation, retrieve_calculation
 from ..folder import Folder
-from ..types import MoleculeInput, SolventInput
+from ..types import MoleculeInput
 from ..utils import api_client
 from .base import (
     Message,
-    Mode,
+    Method,
+    MultiStageOptSettings,
+    Settings,
+    Task,
     Workflow,
     WorkflowResult,
     molecule_to_dict,
@@ -129,10 +132,7 @@ class SpinStatesResult(WorkflowResult):
 def submit_spin_states_workflow(
     initial_molecule: MoleculeInput,
     states: list[int],
-    mode: Mode = Mode.RAPID,
-    solvent: SolventInput = None,
-    xtb_preopt: bool = True,
-    frequencies: bool = False,
+    multistage_opt_settings: MultiStageOptSettings | None = None,
     name: str = "Spin States Workflow",
     folder_uuid: str | None = None,
     folder: Folder | None = None,
@@ -143,13 +143,14 @@ def submit_spin_states_workflow(
     """
     Submits a spin-states workflow to the API.
 
+    Defaults to a `r2scan_3c//gfn2_xtb` stack. Pass an explicit
+    `MultiStageOptSettings(...)` to override.
+
     :param initial_molecule: Molecule to calculate spin states for.
     :param states: List of multiplicities to calculate
         (e.g., [1, 3, 5] for singlet, triplet, quintet).
-    :param mode: Mode to run the calculation in.
-    :param solvent: Solvent to use for the calculation.
-    :param xtb_preopt: Whether to pre-optimize with xTB.
-    :param frequencies: Whether to calculate frequencies.
+    :param multistage_opt_settings: Optimization stages and singlepoint settings
+        describing the method stack.
     :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.
@@ -170,13 +171,18 @@ def submit_spin_states_workflow(
     for mult in states:
         _validate_multiplicity(mol_dict, mult)
 
+    if multistage_opt_settings is None:
+        multistage_opt_settings = MultiStageOptSettings(
+            optimization_settings=[
+                Settings(method=Method.GFN2_XTB, tasks=[Task.OPTIMIZE]),
+            ],
+            singlepoint_settings=Settings(method=Method.R2SCAN3C, tasks=[Task.ENERGY]),
+        )
+
     workflow = stjames.SpinStatesWorkflow(
         initial_molecule=mol_dict,
         states=states,
-        mode=mode,
-        solvent=solvent,
-        xtb_preopt=xtb_preopt,
-        frequencies=frequencies,
+        multistage_opt_settings=multistage_opt_settings,
     )
 
     data = {

rowan/workflows/strain.py

@@ -129,10 +129,11 @@ def submit_strain_workflow(
     :param harmonic_constraint_spring_constant: Spring constant for harmonic
         constraints (kcal/mol/A). Default 5.0.
     :param constrain_hydrogens: Whether to constrain hydrogen positions. Default False.
-    :param conf_gen_settings: Conformer generation settings. Defaults to ETKDG with
-        max 200 conformers.
+    :param conf_gen_settings: Conformer generation settings. Defaults to RDKit
+        ETKDG with max 200 conformers (no solvent).
     :param multistage_opt_settings: Optimization settings for conformer ranking.
-        Defaults to AIMNet2/wB97M-D3 optimization with CPCMx singlepoint.
+        Defaults to GFN2-xTB optimization in water (ALPB) with a g-xTB singlepoint
+        in water (CPCMx).
     :param name: Name of the workflow.
     :param folder_uuid: UUID of the folder to store the workflow in.
     :param folder: Folder object to store the workflow in.

{rowan_python-3.0.7.dist-info → rowan_python-3.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rowan-python
-Version: 3.0.7
+Version: 3.0.9
 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.174
+Requires-Dist: stjames>=0.0.183
 Description-Content-Type: text/markdown
 
 # Rowan Python Library

{rowan_python-3.0.7.dist-info → rowan_python-3.0.9.dist-info}/RECORD

@@ -1,4 +1,5 @@
-rowan/__init__.py,sha256=HvGc27Y6l1_E_mcvabDhmDOOtMrJ6ME7Cx8LfVKqyVs,835
+rowan/__init__.py,sha256=wiEroKH5I6VQ-tiseUcrNGJaS_0soFnYMX0EtpwyLIs,859
+rowan/api_keys.py,sha256=TvG5l5MmQ3Qt8Z3Y7jCA_lcrwEHuI7xHy-KLbIdQ8_A,4793
 rowan/calculation.py,sha256=lZZ52DxPsuJWCTzFZXjhauHK6dV0KCUwzoxtmoxSY48,3442
 rowan/config.py,sha256=3cVKHUNzkIPnN2bvx7l5sia7Zc5poXS8lKOJlowXyLA,21088
 rowan/constants.py,sha256=emCH4m9OL2Hm5E-6mJGM_FgzrK_JrZT-FiKJ6pMNQ4Y,84
@@ -12,19 +13,19 @@ rowan/user.py,sha256=Tnwz1-u_92ACt1xATQegtMj3FcosFsAG4m-4YuAkiyg,5955
 rowan/utils.py,sha256=c1s6Ze-OqLtfvrD23OV60otskejmj-CD88nNf8_nFcw,3636
 rowan/rowan_rdkit/__init__.py,sha256=EATX2VRzywzKxqkpCUMTf7RNQLkWsfi5VcCNDW6EIiw,503
 rowan/rowan_rdkit/chem_utils.py,sha256=ZWdLziT59Qr5JzjvV789CAyRq0m5JIawsOP4RxUbQQA,35529
-rowan/workflows/__init__.py,sha256=UTkqcsqtANh9TtaYXwOSYmTOvzR9ucQ_xhDupAFHROI,4351
+rowan/workflows/__init__.py,sha256=CM3GKDTafp6vl79dWqSOvkVfwH1Ty8zuc8yzi65ABxM,4438
 rowan/workflows/admet.py,sha256=0_wIwXXLfHF-3kgGx_1EM1ljjaYHLeEijJ-GbMYxpL8,2904
 rowan/workflows/analogue_docking.py,sha256=LJpbbaug0tZ9Cg-m0b7EgGH5hJ5894fHOC16Wefx7mE,9206
-rowan/workflows/base.py,sha256=eLGyzTc9NpXBGC-FRjsaUwKP6RluWrz0ipDZ4jDY_jc,30103
+rowan/workflows/base.py,sha256=AyV4ZBta4vz0eiOCi9mcDPTbh-30x-11lfKKwcRJdQw,30330
 rowan/workflows/basic_calculation.py,sha256=FKYczKpYaGE-koaHKi2VARmV9Nhqr0lTOx0Jv1RzC7k,10835
 rowan/workflows/batch_docking.py,sha256=u_4hH7OeWkIbXqEm4uWTc3p0u9mpnR8EWqWCw7sVya4,3581
-rowan/workflows/bde.py,sha256=cM8UNBYycwLE5yJeh8DEtX6mW6hghsM6XKEFkbd7Q8g,5551
-rowan/workflows/conformer_search.py,sha256=_uCfGFsUTDyxDc55XTsvMSjs800LyfzBRa4_-9Pjp4g,7690
+rowan/workflows/bde.py,sha256=JJUx2wFJ8yZu0sqIn7Jkm6B6O84WrrpAstCck8c7FLI,5621
+rowan/workflows/conformer_search.py,sha256=rzarx3PKRM2rf9x1F17Jg8ZCed7_3-yEBan4g0b2HK4,9868
 rowan/workflows/constants.py,sha256=el8jWE9gnGTLNWn5_n_V0H362vIRneOqgy7BOQ8CScg,575
 rowan/workflows/descriptors.py,sha256=rGrNca6kA4SzX5BAOjP6rE91MOLTvCWSYKF_LW2Z0y4,2963
 rowan/workflows/docking.py,sha256=wmE7QJu1uDHBDynTT1XesXXAZtpB6xLjZUKsHOQyCcU,7386
 rowan/workflows/double_ended_ts_search.py,sha256=abBblMkshhbzq5UTwIf-ovNFxY8Ltp2O-bGu_plkI58,7806
-rowan/workflows/electronic_properties.py,sha256=2L0BUvhx0iT0k4gQf7hbceCpatznT2xui7rs6lpME7k,7564
+rowan/workflows/electronic_properties.py,sha256=ia4mlmgnioEuLDrcgDuxAyyI6VqRkdxBqshjb9uiEI8,8385
 rowan/workflows/fukui.py,sha256=wLimH3QmorSpvkovRPlI91VuxHG4J91F2EcLYqg3eP0,5112
 rowan/workflows/hydrogen_bond_donor_acceptor_strength.py,sha256=WWiEK_GlumIEgTTOaqw-Y5gPDkRkaePWcIjTdIocrPc,4916
 rowan/workflows/interaction_energy_decomposition.py,sha256=Kjwkb-pviFSFIIZNjMb9i8nAkdKrbjFftmG_lkYtE40,6120
@@ -33,24 +34,24 @@ rowan/workflows/irc.py,sha256=BH6s0rJEQ3G5yN5mOOSGfiZCf-i6YZNUgtK2-m-gmdo,7491
 rowan/workflows/macropka.py,sha256=YkXoPiyou6nAoBheES0endsqNdi_kclwlIscTljNuKI,5723
 rowan/workflows/membrane_permeability.py,sha256=oIDmB8qF_K_Kesv7o_FiljAk4dpptEeOjoxtMvl1gSw,4612
 rowan/workflows/msa.py,sha256=V3B1SyWPR8MT306hh9W-T9JTpi_E-XgAIeF9yRQZ7tI,5075
-rowan/workflows/multistage_optimization.py,sha256=HFVx8mnHxG97pDYyL6eOhNGmESqTxaKNgUdwrFpFUJ0,6456
+rowan/workflows/multistage_optimization.py,sha256=9PbLHOXtM2TLCVl_ZY7JH6QCUudHWTn4R14_KsZF-v8,6840
 rowan/workflows/nmr.py,sha256=hergJdsiawKj7iV-jHxDOS03n_EnZcaCIt_ZTl34-JY,5183
 rowan/workflows/pka.py,sha256=TCFSE5HI5JLPslKdbUvJe4IxrVaLExrI_3PnDfXtxTw,8691
 rowan/workflows/pocket_detection.py,sha256=aGHY0puxekp4c4nsNYHcvKCe1fsetygL04BcSvNFvE8,3864
 rowan/workflows/pose_analysis_md.py,sha256=UvotLhWv0_VAkKteZboOutDry7l-Zt1K6_SBx3EXqgM,9530
 rowan/workflows/protein_binder_design.py,sha256=J-9NSbRLdHb6JQRhY_vq43HlHCDCiQqrkOZUCAF-2dk,8604
-rowan/workflows/protein_cofolding.py,sha256=1R29XjAVjWHyelGG-mylP2GIamZbLCQKaaaFsCAnYgI,13012
+rowan/workflows/protein_cofolding.py,sha256=D2PVwL51H3traml1JDG-9jU3R0E29AdfR9Bk0tLX1Zw,14093
 rowan/workflows/protein_md.py,sha256=_n0IdmTQsunbP1geF-wUjXNMKNYV-ngmAPEMJlj0dkI,7021
 rowan/workflows/rbfe_graph.py,sha256=PLqzBRkxD7tPdBViYJZjgaCP8aA2UXKc9dD4odx5XUo,5788
-rowan/workflows/redox_potential.py,sha256=lg2Djev58oOmBmI4l3eIaGKafkNXMhwo17K2G7kQvjY,5319
+rowan/workflows/redox_potential.py,sha256=SBV1n6RXh4_vVVaEFpJx3iru_3UAOwDNgqOi8K6eHkU,5382
 rowan/workflows/relative_binding_free_energy_perturbation.py,sha256=uxC3Rr63U6GjNa9u2Hurahu48l4rYEz5RQX4hV0D250,13456
 rowan/workflows/scan.py,sha256=KQm58utOxs6qIpX1Jv3usoUpkVHeLw4mKCs8RTUkRhk,5696
 rowan/workflows/solubility.py,sha256=9-zHEHkf4AgGNDCE3x1S-6wTgwxVm4ihRmh0kwLvPFs,8594
 rowan/workflows/solvent_dependent_conformers.py,sha256=ovvnhCE4xlkpdhccLHEq7oBJRI2-rHmZ-7_ewGECerM,7020
-rowan/workflows/spin_states.py,sha256=GZgBJPO6_ds9el4b7wbigIZ5213Z9DwXhokczJ5NDhs,7122
-rowan/workflows/strain.py,sha256=r0tlZoUlAslAiF7dPTpa9WlQFUAKyVjZ19zASjSS8Hs,6339
+rowan/workflows/spin_states.py,sha256=c0y2cwO9NE8DmxmQ9ZouA5QoBhxgZiTYFIqhC-geVAo,7382
+rowan/workflows/strain.py,sha256=tb6PGng8B4wSDl4a_MWd0P-cdlSTRpT410VgOJAqXHQ,6393
 rowan/workflows/tautomer_search.py,sha256=aqwXoj0ffWsb5gbvzfz_bpx5ifIfR_K07fbdWhU62Ko,5820
-rowan_python-3.0.7.dist-info/METADATA,sha256=-sirW_Q74BeqsjNRR4wAWYoV8ebpuNLzc6-8FrgOKRs,1600
-rowan_python-3.0.7.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-rowan_python-3.0.7.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
-rowan_python-3.0.7.dist-info/RECORD,,
+rowan_python-3.0.9.dist-info/METADATA,sha256=IdBYpQWGOhztIvdM5El7LpplQu9kzzF46ATGkgPIJMc,1600
+rowan_python-3.0.9.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+rowan_python-3.0.9.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
+rowan_python-3.0.9.dist-info/RECORD,,