rowan-python 0.0.5__py3-none-any.whl → 1.1.0__py3-none-any.whl

rowan/__init__.py

@@ -1,4 +1,10 @@
 # ruff: noqa
 
 from . import utils
-from .client import Client
+from .client import compute
+
+from . import constants
+
+from .folder import Folder
+from .workflow import Workflow
+from .calculation import Calculation

rowan/calculation.py

@@ -0,0 +1,11 @@
+import stjames
+
+from .utils import api_client
+
+class Calculation:
+    @classmethod
+    def retrieve(cls, uuid: stjames.UUID) -> dict:
+        with api_client() as client:
+            response = client.get(f"/calculation/{uuid}/stjames")
+            response.raise_for_status()
+            return response.json()

rowan/client.py

@@ -1,155 +1,50 @@
-from __future__ import annotations
-
 import cctk
-import httpx
-from typing import Optional
 import stjames
-from dataclasses import dataclass, field
 import time
+from typing import Optional
 
-import rowan
-
-API_URL = "https://api.rowansci.com"
-
-
-@dataclass
-class Client:
-    blocking: bool = True
-    print: bool = True
-    ping_interval: int = 5
-    delete_when_finished: bool = False
-
-    headers: dict = field(init=False)
-
-    def __post_init__(self):
-        self.headers = {"X-API-Key": rowan.utils.get_api_key()}
-
-        if not self.blocking and self.delete_when_finished:
-            print("Warning: ``delete_when_finished`` has no effect when ``blocking`` is False. To delete calculations, call ``Client.delete()`` manually.")
-
-    def compute(
-        self,
-        type: Optional[str] = "calculation",
-        input_mol: Optional[cctk.Molecule] = None,
-        input_smiles: Optional[str] = None,
-        name: Optional[str] = None,
-        folder_uuid: Optional[str] = None,
-        engine: str = "peregrine",
-        **options,
-    ) -> dict | str:
-        if (input_mol is None) == (input_smiles is None):
-            raise ValueError("Must specify exactly one of ``input_smiles`` and ``input_mol``!")
-
-        if input_mol is None:
-            input_mol = cctk.Molecule.new_from_smiles(input_smiles)
-
-        molecule = rowan.utils.cctk_to_stjames(input_mol)
-
-        with httpx.Client() as client:
-            if type == "calculation":
-                settings = stjames.Settings(**options)
-                calc = stjames.Calculation(molecules=[molecule], name=name, engine=engine, settings=settings)
-
-                response = client.post(
-                    f"{API_URL}/calculation",
-                    headers=self.headers,
-                    json={
-                        "json_data": calc.model_dump(mode="json"),
-                        "folder_uuid": folder_uuid,
-                    },
-                )
-
-            else:
-                response = client.post(
-                    f"{API_URL}/workflow",
-                    headers=self.headers,
-                    json={
-                        "initial_molecule": molecule.model_dump(mode="json"),
-                        "workflow_type": type,
-                        "name": name,
-                        "folder_uuid": folder_uuid,
-                        "workflow_data": options,
-                    },
-                )
-
-            response.raise_for_status()
-            response_dict = response.json()
-            calc_uuid = response_dict["uuid"]
-
-        if self.blocking:
-            while not self.is_finished(calc_uuid, type):
-                time.sleep(self.ping_interval)
-            result = self.get(calc_uuid, type)
-
-            if self.delete_when_finished:
-                self.delete(calc_uuid, type)
-
-            return result
-
-        else:
-            return calc_uuid
-
-    def is_finished(self, calc_uuid: str, type: str = "calculation") -> bool:
-        with httpx.Client() as client:
-            if type == "calculation":
-                response = client.get(f"{API_URL}/calculation/{calc_uuid}", headers=self.headers)
-                response.raise_for_status()
-                response_dict = response.json()
-                status = response_dict["status"]
-
-            else:
-                response = client.get(f"{API_URL}/workflow/{calc_uuid}", headers=self.headers)
-                response.raise_for_status()
-                response_dict = response.json()
-                status = response_dict["object_status"]
-
-        return status in [2, 3, 4]
-
-    def get(self, calc_uuid: str, type: str = "calculation") -> dict:
-        with httpx.Client() as client:
-            if type == "calculation":
-                stj_response = client.get(f"{API_URL}/calculation/{calc_uuid}/stjames", headers=self.headers)
-                stj_response.raise_for_status()
-                stj_dict = stj_response.json()
-
-                response = client.get(f"{API_URL}/calculation/{calc_uuid}", headers=self.headers)
-                response.raise_for_status()
-                response_dict = response.json()
-
-                # reformat
-                del response_dict["settings"]
-                response_dict["data"] = stj_dict
-
-                return response_dict
-
-            else:
-                response = client.get(f"{API_URL}/workflow/{calc_uuid}", headers=self.headers)
-                response.raise_for_status()
-                response_dict = response.json()
-
-                # reformat
-                response_dict["data"] = response_dict["object_data"]
-                del response_dict["object_data"]
-                del response_dict["status"]
-
-                return response_dict
-
-    def stop(self, calc_uuid: str, type: str = "calculation") -> None:
-        with httpx.Client() as client:
-            if type == "calculation":
-                response = client.post(f"{API_URL}/calculation/{calc_uuid}/stop", headers=self.headers)
-                response.raise_for_status()
-
-            else:
-                response = client.post(f"{API_URL}/workflow/{calc_uuid}/stop", headers=self.headers)
-                response.raise_for_status()
-
-    def delete(self, calc_uuid: str, type: str = "calculation") -> None:
-        with httpx.Client() as client:
-            if type == "calculation":
-                response = client.delete(f"{API_URL}/calculation/{calc_uuid}", headers=self.headers)
-                response.raise_for_status()
-
-            else:
-                response = client.delete(f"{API_URL}/folder/{calc_uuid}", headers=self.headers)
-                response.raise_for_status()
+from .utils import cctk_to_stjames, smiles_to_stjames
+from .workflow import Workflow
+
+""" A high-level interface to submitting a calculation. """
+
+
+def compute(
+    molecule: str | cctk.Molecule | stjames.Molecule,
+    workflow_type: str,
+    name: str = "",
+    folder_uuid: Optional[stjames.UUID] = None,
+    blocking: bool = True,
+    ping_interval: int = 5,
+    **workflow_data,
+) -> dict:
+    """High-level function to compute and return workflows."""
+
+    if isinstance(molecule, str):
+        stjmol = smiles_to_stjames(molecule)
+    elif isinstance(molecule, cctk.Molecule):
+        stjmol = cctk_to_stjames(molecule)
+    elif isinstance(molecule, stjames.Molecule):
+        stjmol = molecule
+    else:
+        raise ValueError("Invalid type for `molecule`!")
+
+    result = Workflow.submit(
+        initial_molecule=stjmol,
+        workflow_type=workflow_type,
+        name=name,
+        folder_uuid=folder_uuid,
+        workflow_data=workflow_data,
+    )
+
+    if blocking:
+        uuid = result["uuid"]
+
+        while not Workflow.is_finished(uuid):
+            time.sleep(ping_interval)
+
+        completed_result = Workflow.retrieve(uuid)
+        return completed_result
+
+    else:
+        return result

rowan/constants.py

@@ -0,0 +1 @@
+API_URL = "https://api.rowansci.com"

rowan/folder.py

@@ -0,0 +1,97 @@
+import stjames
+from typing import Optional
+
+from .utils import api_client
+
+
+class Folder:
+    @classmethod
+    def create(
+        cls,
+        name: str,
+        parent_uuid: Optional[stjames.UUID] = None,
+        notes: str = "",
+        starred: bool = False,
+        public: bool = False,
+    ) -> dict:
+        with api_client() as client:
+            response = client.post(
+                "/folder",
+                json={
+                    "name": name,
+                    "parent_uuid": parent_uuid,
+                    "notes": notes,
+                    "starred": starred,
+                    "public": public,
+                },
+            )
+            response.raise_for_status()
+            return response.json()
+
+    @classmethod
+    def retrieve(cls, uuid: stjames.UUID) -> dict:
+        with api_client() as client:
+            response = client.get(f"/folder/{uuid}")
+            response.raise_for_status()
+            return response.json()
+
+    @classmethod
+    def update(
+        cls,
+        uuid: stjames.UUID,
+        name: Optional[str] = None,
+        parent_uuid: Optional[stjames.UUID] = None,
+        notes: Optional[str] = None,
+        starred: Optional[bool] = None,
+        public: Optional[bool] = None,
+    ) -> None:
+        old_data = cls.retrieve(uuid)
+
+        new_data = {}
+        new_data["name"] = name if name is not None else old_data["name"]
+        new_data["parent_uuid"] = (
+            parent_uuid if parent_uuid is not None else old_data["parent_uuid"]
+        )
+        new_data["notes"] = notes if notes is not None else old_data["notes"]
+        new_data["starred"] = starred if starred is not None else old_data["starred"]
+        new_data["public"] = public if public is not None else old_data["public"]
+
+        with api_client() as client:
+            response = client.post(f"/folder/{uuid}", json=new_data)
+            response.raise_for_status()
+            return response.json()
+
+    @classmethod
+    def delete(cls, uuid: stjames.UUID) -> None:
+        with api_client() as client:
+            response = client.delete(f"/folder/{uuid}")
+            response.raise_for_status()
+
+    @classmethod
+    def list(
+        cls,
+        parent_uuid: Optional[stjames.UUID] = None,
+        name_contains: Optional[str] = None,
+        public: Optional[bool] = None,
+        starred: Optional[bool] = None,
+        page: int = 0,
+        size: int = 10,
+    ):
+        params = {"page": page, "size": size}
+
+        if parent_uuid is not None:
+            params["parent_uuid"] = parent_uuid
+
+        if name_contains is not None:
+            params["name_contains"] = name_contains
+
+        if public is not None:
+            params["public"] = public
+
+        if starred is not None:
+            params["starred"] = starred
+
+        with api_client() as client:
+            response = client.get("/folder", params=params)
+            response.raise_for_status()
+            return response.json()

rowan/rowan_rdkit/__init__.py

@@ -0,0 +1,3 @@
+from .chem_utils import pka, tautomers, conformers, energy, optimize, batch_pka, batch_tautomers, batch_energy, batch_optimize, batch_conformers
+
+__all__ = ["pka", "tautomers", "energy", "conformers", "optimize", "batch_pka", "batch_tautomers", "batch_energy", "batch_optimize",  "batch_conformers"]

rowan/rowan_rdkit/chem_utils.py

@@ -0,0 +1,610 @@
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from typing import Literal, TypeAlias, Optional, List
+import rowan
+import copy
+import asyncio
+import logging
+import math
+from rowan.utils import get_api_key
+import stjames
+import time
+import numpy as np
+import cctk
+
+RdkitMol: TypeAlias = Chem.rdchem.Mol | Chem.rdchem.RWMol
+pKaMode = Literal["reckless", "rapid", "careful"]
+TautomerMode = Literal["reckless", "rapid", "careful"]
+ConformerMode = Literal["reckless", "rapid"]
+FAST_METHODS: list[stjames.Method] = [
+    *stjames.method.XTB_METHODS,
+    *stjames.method.NNP_METHODS,
+]
+
+class ConversionError(ValueError):
+    pass
+
+class NoConformersError(Exception):
+    pass
+
+class MethodTooSlowError(Exception):
+    pass
+
+def _get_rdkit_mol_from_uuid(calculation_uuid: str) -> RdkitMol:
+    stjames_mol_dict = rowan.Calculation.retrieve(calculation_uuid)["molecules"][-1]
+    stjames_mol = stjames.Molecule(**stjames_mol_dict)
+    rdkm = Chem.MolFromXYZBlock(stjames_mol.to_xyz())
+    return rdkm
+
+def embed_rdkit_mol(rdkm: RdkitMol):
+    try:
+        AllChem.SanitizeMol(rdkm)
+    except Exception as e:
+        raise ValueError(f"Molecule could not be generated -- invalid chemistry!\n{e}")
+
+    rdkm = AllChem.AddHs(rdkm)
+    try:
+        status1 = AllChem.EmbedMolecule(rdkm, maxAttempts=200)
+        assert status1 >= 0
+    except Exception as e:
+        status1 = AllChem.EmbedMolecule(rdkm, maxAttempts=200, useRandomCoords=True)
+        if status1 < 0:
+            raise ValueError(f"Cannot embed molecule! Error: {e}")
+    try:
+        status2 = AllChem.MMFFOptimizeMolecule(rdkm, maxIters=200)
+        assert status2 >= 0
+    except AssertionError:
+        pass
+    
+    return rdkm
+
+def rdkit_to_cctk(rdkm: RdkitMol, cid: int = 0) -> cctk.Molecule:
+    if len(rdkm.GetConformers()) == 0:
+        rdkm = embed_rdkit_mol(rdkm)
+    try:
+        nums = [atom.GetAtomicNum() for atom in rdkm.GetAtoms()]
+        geom = rdkm.GetConformers()[cid].GetPositions()
+        return cctk.Molecule(nums, geom, charge=Chem.GetFormalCharge(rdkm))
+    except IndexError as e:
+        raise ConversionError("RDKit molecule does not have a conformer with the given ID") from e
+    
+def cctk_to_stjames(cmol: cctk.Molecule) -> stjames.Molecule:
+    atomic_numbers = cmol.atomic_numbers.view(np.ndarray)
+    geometry = cmol.geometry.view(np.ndarray)
+    atoms = []
+    for i in range(cmol.num_atoms()):
+        atoms.append(stjames.Atom(atomic_number=atomic_numbers[i], position=geometry[i]))
+
+    return stjames.Molecule(atoms=atoms, charge=cmol.charge, multiplicity=cmol.multiplicity)
+
+def rdkit_to_stjames(rdkm: RdkitMol, cid: int = 0) -> stjames.Molecule:
+    cmol = rdkit_to_cctk(rdkm, cid)
+    return cctk_to_stjames(cmol)
+
+def pka(mol: RdkitMol,
+        mode: pKaMode = "rapid",
+        timeout: int = 600,
+        name: str = "pKa API Workflow",
+        pka_range: tuple[int, int] = (2, 12),
+        deprotonate_elements: list[int] = [7, 8, 16],
+        protonate_elements: list[int] = [7],
+        folder_uuid: Optional[stjames.UUID] = None)-> tuple[dict[int, float], dict[int, float]]:
+    return asyncio.run(_single_pka(mol, mode, timeout, name, pka_range, deprotonate_elements, protonate_elements, folder_uuid))
+
+def batch_pka(mols: List[RdkitMol],
+        mode: pKaMode = "rapid",
+        timeout: int = 600,
+        name: str = "pKa API Workflow",
+        pka_range: tuple[int, int] = (2, 12),
+        deprotonate_elements: list[int] = [7, 8, 16],
+        protonate_elements: list[int] = [7],
+        folder_uuid: Optional[stjames.UUID] = None)-> tuple[dict[int, float], dict[int, float]]:
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    tasks = [
+        _single_pka(mol, mode, timeout, name, pka_range, deprotonate_elements, protonate_elements, folder_uuid)
+        for mol in mols
+    ]
+    results = loop.run_until_complete(asyncio.gather(*tasks))
+    return results
+
+
+async def _single_pka(mol: RdkitMol,
+        mode: pKaMode = "rapid",
+        timeout: int = 600,
+        name: str = "pKa API Workflow",
+        pka_range: tuple[int, int] = (2, 12),
+        deprotonate_elements: list[int] = [7, 8, 16],
+        protonate_elements: list[int] = [7],
+        folder_uuid: Optional[stjames.UUID] = None) -> tuple[dict[int, float], dict[int, float]]:
+    """
+    Calculate the pKa of a molecule.
+    :param mol: RDKit molecule object
+    :return: dictionary of pKa values
+    """
+    get_api_key()
+    post = rowan.Workflow.submit(
+        name=name,
+        workflow_type="pka",
+        initial_molecule=rdkit_to_stjames(mol),
+        workflow_data={
+            "pka_range": pka_range,
+            "deprotonate_elements": deprotonate_elements,
+            "deprotonate_atoms": [],
+            "protonate_elements": protonate_elements,
+            "protonate_atoms": [],
+            "mode": mode,
+        },
+        folder_uuid=folder_uuid
+    )
+    
+    start = time.time()
+    while not rowan.Workflow.is_finished(post["uuid"]):
+        await asyncio.sleep(5)
+        if time.time() - start > timeout:
+            raise TimeoutError("Workflow timed out")
+        
+    result = rowan.Workflow.retrieve(post["uuid"])
+    
+    acidic_pkas = []
+    for microstate in result["object_data"]["conjugate_bases"]:
+        symbol = cctk.helper_functions.get_symbol(result["object_data"]["initial_molecule"]["atoms"][microstate["atom_index"]-1]["atomic_number"])
+        acidic_pkas.append({
+            "element": symbol,
+            "index": microstate["atom_index"],
+            "pKa": round(microstate["pka"], 2)
+        })
+        
+
+    basic_pkas = []
+    for microstate in result["object_data"]["conjugate_acids"]:
+        symbol = cctk.helper_functions.get_symbol(result["object_data"]["initial_molecule"]["atoms"][microstate["atom_index"]-1]["atomic_number"])
+        basic_pkas.append({
+            "element": symbol,
+            "index": microstate["atom_index"],
+            "pKa": round(microstate["pka"], 2)
+        })
+
+    return {"acidic_pkas": acidic_pkas, "basic_pkas": basic_pkas}
+
+
+def tautomers(mol: RdkitMol,
+              mode: TautomerMode = "reckless",
+              timeout: int = 600,
+              name: str = "Tautomers API Workflow",
+              folder_uuid: Optional[stjames.UUID] = None) -> list[tuple[RdkitMol, float]]:
+    """
+    Generate possible tautomers of a molecule.
+    :param mol: RDKit molecule object
+    :return: A list of tautomer dictionaries which include the RDKit molecule object, the relative energy, and the weight
+    """
+    return asyncio.run(_single_tautomers(mol, mode, timeout, name, folder_uuid))
+
+def batch_tautomers(mols: List[RdkitMol],
+              mode: TautomerMode = "reckless",
+              timeout: int = 600,
+              name: str = "Tautomers API Workflow",
+              folder_uuid: Optional[stjames.UUID] = None) -> list[tuple[RdkitMol, float]]:
+    """
+    Generate possible tautomers of a molecule.
+    :param mol: RDKit molecule object
+    :return: A list of lists of tautomer dictionaries which include the RDKit molecule object, the relative energy, and the weight
+    """
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    tasks = [_single_tautomers(mol, mode, timeout, name, folder_uuid) for mol in mols]
+    results = loop.run_until_complete(asyncio.gather(*tasks))
+    return results
+
+
+async def _single_tautomers(mol: RdkitMol,
+              mode: TautomerMode = "reckless",
+              timeout: int = 600,
+              name: str = "Tautomers API Workflow",
+              folder_uuid: Optional[stjames.UUID] = None) -> list[tuple[RdkitMol, float]]:
+    """
+    Generate possible tautomers of a molecule.
+    :param mol: RDKit molecule object
+    :return: A list of tautomer dictionaries which include the RDKit molecule object, the relative energy, and the weight
+    """
+    get_api_key()
+    post = rowan.Workflow.submit(
+        name=name,
+        workflow_type="tautomers",
+        initial_molecule=rdkit_to_stjames(mol),
+        workflow_data={
+            "mode": mode,
+        },
+        folder_uuid=folder_uuid
+    )
+    
+    start = time.time()
+    while not rowan.Workflow.is_finished(post["uuid"]):
+        await asyncio.sleep(5)
+        if time.time() - start > timeout:
+            raise TimeoutError("Workflow timed out")
+        
+    result = rowan.Workflow.retrieve(post["uuid"])
+    
+    tautomers = []
+    for tautomer in result["object_data"]["tautomers"]:
+        rdkit_mol = _get_rdkit_mol_from_uuid(tautomer["structures"][0]["uuid"])
+        tautomers.append({
+            "molecule": rdkit_mol,
+            "predicted_relative_energy": round(tautomer["predicted_relative_energy"], 2),
+            "weight": round(tautomer["weight"], 5)
+        })
+        
+    #return relative weights too 
+    return tautomers
+
+def energy(
+    mol: RdkitMol,
+    method: str = "aimnet2_wb97md3",
+    engine: str = "aimnet2",
+    mode: str = "auto",
+    timeout: int = 600,
+    name: str = "Energy API Workflow",
+    folder_uuid: Optional[stjames.UUID] = None
+):
+    """
+    Computes the energy for the given molecule.
+
+    :param mol: the input molecule
+    :param method: the method with which to compute the molecule's energy
+    :raises: MethodTooSlowError if the method is invalid
+    :returns: a dictionary with the energy in Hartree and the conformer index
+    """
+    return asyncio.run(_single_energy(mol, method, engine, mode, timeout, name, folder_uuid))
+
+def batch_energy(
+    mols: List[RdkitMol],
+    method: str = "aimnet2_wb97md3",
+    engine: str = "aimnet2",
+    mode: str = "auto",
+    timeout: int = 600,
+    name: str = "Energy API Workflow",
+    folder_uuid: Optional[stjames.UUID] = None
+):
+    """
+    Computes the energy for the given molecule.
+
+    :param mol: the input molecule
+    :param method: the method with which to compute the molecule's energy
+    :raises: MethodTooSlowError if the method is invalid
+    :returns: a list of dictionaries with the energy in Hartree and the conformer index
+    """
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    tasks = [_single_energy(mol, method, engine, mode, timeout, name, folder_uuid) for mol in mols]
+    results = loop.run_until_complete(asyncio.gather(*tasks))
+    return results
+
+async def _single_energy(
+    mol: RdkitMol,
+    method: str = "aimnet2_wb97md3",
+    engine: str = "aimnet2",
+    mode: str = "auto",
+    timeout: int = 600,
+    name: str = "Energy API Workflow",
+    folder_uuid: Optional[stjames.UUID] = None
+):
+    """
+    Computes the energy for the given molecule.
+
+    :param mol: the input molecule
+    :param method: the method with which to compute the molecule's energy
+    :raises: MethodTooSlowError if the method is invalid
+    :returns: a dictionary with the energy in Hartree and the conformer index
+    """
+    get_api_key()
+
+    method = stjames.Method(method)
+
+    if mol.GetNumConformers() == 0:
+        mol = embed_rdkit_mol(mol)
+        if mol.GetNumConformers() == 0:
+            raise NoConformersError("This molecule has no conformers")
+
+    if method not in FAST_METHODS:
+        raise MethodTooSlowError(
+            "This method is too slow; try running this through our web interface."
+        )
+
+    workflow_uuids = []
+    for conformer in mol.GetConformers():
+        cid = conformer.GetId()
+        stjames_mol = rdkit_to_stjames(mol, cid)
+        get_api_key()
+        post = rowan.Workflow.submit(
+            name=name,
+            workflow_type="basic_calculation",
+            initial_molecule=stjames_mol,
+            workflow_data={
+            "settings": {
+                        "method": method.value,
+                        "corrections": [],
+                        "tasks": [
+                            "energy"
+                        ],
+                        "mode": mode,
+                        "opt_settings": {
+                            "constraints": []
+                        }
+                    },
+            "engine": engine
+                },
+            folder_uuid=folder_uuid
+        )
+        
+        workflow_uuids.append(post["uuid"])
+        
+    start = time.time()
+    while not all(rowan.Workflow.is_finished(uuid) for uuid in workflow_uuids):
+        await asyncio.sleep(5)
+        if time.time() - start > timeout:
+            raise TimeoutError("Workflow timed out")
+        
+    workflow_results = [rowan.Workflow.retrieve(uuid) for uuid in workflow_uuids]
+    energies = [rowan.Calculation.retrieve(workflow["object_data"]["calculation_uuid"])["molecules"][-1]["energy"] for workflow in workflow_results]
+
+    return [{"conformer_index": index, "energy": energy} for index, energy in enumerate(energies)]
+        
+        
+def optimize(
+    mol: RdkitMol,
+    method: str = "aimnet2_wb97md3",
+    engine: str = "aimnet2",
+    mode: str = "auto",
+    return_energies: bool = False,
+    timeout: int = 600,
+    name: str = "Optimize API Workflow",
+    folder_uuid: Optional[stjames.UUID] = None
+) -> RdkitMol | tuple[RdkitMol, dict[int, float]]:
+    """
+    Optimize each of a molecule's conformers and then return the molecule.
+
+    :param mol: the input molecule
+    :param method: the method with which to compute the molecule's energy
+    :param return_energies: whether to return energies in Hartree too
+    :raises: MethodTooSlowError if the method is invalid
+    :returns: a dictionary with the molecule, with optimized conformers, and optionally a list of energies per conformer too
+
+    """
+    return asyncio.run(_single_optimize(mol, method, engine, mode, return_energies, timeout, name, folder_uuid))
+
+def batch_optimize(
+    mols: List[RdkitMol],
+    method: str = "aimnet2_wb97md3",
+    engine: str = "aimnet2",
+    mode: str = "auto",
+    return_energies: bool = False,
+    timeout: int = 600,
+    name: str = "Optimize API Workflow",
+    folder_uuid: Optional[stjames.UUID] = None
+) -> RdkitMol | tuple[RdkitMol, dict[int, float]]:
+    """
+    Optimize each of a molecule's conformers and then return the molecule.
+
+    :param mol: the input molecule
+    :param method: the method with which to compute the molecule's energy
+    :param return_energies: whether to return energies in Hartree too
+    :raises: MethodTooSlowError if the method is invalid
+    :returns: a list of dictionaries with the molecule, with optimized conformers, and optionally a list of energies per conformer too
+
+    """
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    tasks = [_single_optimize(mol, method, engine, mode, return_energies, timeout, name, folder_uuid) for mol in mols]
+    results = loop.run_until_complete(asyncio.gather(*tasks))
+    return results
+
+async def _single_optimize(
+    mol: RdkitMol,
+    method: str = "aimnet2_wb97md3",
+    engine: str = "aimnet2",
+    mode: str = "auto",
+    return_energies: bool = False,
+    timeout: int = 600,
+    name: str = "Optimize API Workflow",
+    folder_uuid: Optional[stjames.UUID] = None
+) -> RdkitMol | tuple[RdkitMol, dict[int, float]]:
+    """
+    Optimize each of a molecule's conformers and then return the molecule.
+
+    :param mol: the input molecule
+    :param method: the method with which to compute the molecule's energy
+    :param return_energies: whether to return energies in Hartree too
+    :raises: MethodTooSlowError if the method is invalid
+    :returns: a dictionary with the molecule, with optimized conformers, and optionally a list of energies per conformer too
+
+    """
+    get_api_key()
+
+    method = stjames.Method(method)
+    
+    if mol.GetNumConformers() == 0:
+        mol = embed_rdkit_mol(mol)
+        if mol.GetNumConformers() == 0:
+            raise NoConformersError("This molecule has no conformers")
+
+    if method not in FAST_METHODS:
+        raise MethodTooSlowError(
+            "This method is too slow; try running this through our web interface."
+        )
+
+    optimized_mol = copy.deepcopy(mol)
+    
+    workflow_uuids = []
+    for conformer in mol.GetConformers():
+        cid = conformer.GetId()
+        stjames_mol = rdkit_to_stjames(mol, cid)
+        get_api_key()
+        post = rowan.Workflow.submit(
+            name=name,
+            workflow_type="basic_calculation",
+            initial_molecule=stjames_mol,
+            workflow_data={
+                "settings": {
+                    "method": method.value,
+                    "corrections": [],
+                    "tasks": [
+                        "optimize"
+                    ],
+                    "mode": mode,
+                    "opt_settings": {
+                        "constraints": []
+                    }
+                },
+                "engine": engine
+            },
+            folder_uuid=folder_uuid
+        )
+        
+        workflow_uuids.append(post["uuid"])
+        
+    start = time.time()
+    while not all(rowan.Workflow.is_finished(uuid) for uuid in workflow_uuids):
+        await asyncio.sleep(5)
+        if time.time() - start > timeout:
+            raise TimeoutError("Workflow timed out")
+        
+    workflow_results = [rowan.Workflow.retrieve(uuid) for uuid in workflow_uuids]
+    calculations = [rowan.Calculation.retrieve(workflow["object_data"]["calculation_uuid"]) for workflow in workflow_results]
+    optimization_atoms = [cacluation["molecules"][-1]["atoms"] for cacluation in calculations]
+    optimized_positions = [[atom["position"] for atom in atoms] for atoms in optimization_atoms]
+    
+    energies = [cacluation["molecules"][-1]["energy"] for cacluation in calculations]
+    
+    for i, conformer in enumerate(optimized_mol.GetConformers()):
+        conformer.SetPositions(np.array(optimized_positions[i]))
+        
+    return_dict = {"rdkit_molecule": mol}
+    
+    if return_energies:
+        return_dict["energies"] = energies
+
+    return return_dict
+
+def conformers(mol: RdkitMol, num_conformers=10,
+               method: str = "aimnet2_wb97md3",
+               mode: str = "rapid",
+               return_energies: bool = False,
+               timeout: int = 600,
+               name: str = "Conformer API Workflow",
+               folder_uuid: Optional[stjames.UUID] = None):
+    """
+    Generate conformers for a molecule.
+    :param mol: RDKit molecule object
+    :param num_conformers: Number of conformers to generate
+    :return: A dictonary with the RDKit molecule with num_conformers lowest energy conformers and optional energies
+    """
+    return asyncio.run(_single_conformers(mol, num_conformers, method, mode, return_energies, timeout, name, folder_uuid))
+
+def batch_conformers(mols: List[RdkitMol], num_conformers=10,
+               method: str = "aimnet2_wb97md3",
+               mode: str = "rapid",
+               return_energies: bool = False,
+               timeout: int = 600,
+               name: str = "Conformer API Workflow",
+               folder_uuid: Optional[stjames.UUID] = None):
+    """
+    Generate conformers for a molecule.
+    :param mol: RDKit molecule object
+    :param num_conformers: Number of conformers to generate
+    :return: A list of dictonaries with the RDKit molecule with num_conformers lowest energy conformers and optional energies
+    """
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    tasks = [_single_conformers(mol, num_conformers, method, mode, return_energies, timeout, name, folder_uuid) for mol in mols]
+    results = loop.run_until_complete(asyncio.gather(*tasks))
+    return results
+
+
+async def _single_conformers(mol: RdkitMol, num_conformers=10,
+               method: str = "aimnet2_wb97md3",
+               mode: str = "rapid",
+               return_energies: bool = False,
+               timeout: int = 600,
+               name: str = "Conformer API Workflow",
+               folder_uuid: Optional[stjames.UUID] = None):
+    """
+    Generate conformers for a molecule.
+    :param mol: RDKit molecule object
+    :param num_conformers: Number of conformers to generate
+    :return: A dictonary with the RDKit molecule with num_conformers lowest energy conformers and optional energies
+    """
+    
+    get_api_key()
+
+    method = stjames.Method(method)
+    
+    if mol.GetNumConformers() == 0:
+        mol = embed_rdkit_mol(mol)
+        if mol.GetNumConformers() == 0:
+            raise NoConformersError("This molecule has no conformers")
+
+    if method not in FAST_METHODS:
+        raise MethodTooSlowError(
+            "This method is too slow; try running this through our web interface."
+        )
+    
+    post = rowan.Workflow.submit(
+        name=name,
+        workflow_type="conformer_search",
+        initial_molecule=rdkit_to_stjames(mol),
+        workflow_data={
+        "conf_gen_mode": "rapid",
+        "mode": mode,
+        "mso_mode": "manual",
+        "multistage_opt_settings": {
+            "mode": "manual",
+            "optimization_settings": [
+                {
+                    "method": method.value,
+                    "tasks": [
+                        "optimize"
+                    ],
+                    "corrections": [],
+                    "mode": "auto"
+                }
+            ],
+            "solvent": None,
+            "transition_state": False,
+            "constraints": []
+        }
+    },
+        folder_uuid=folder_uuid
+    )
+    
+    start = time.time()
+    while not rowan.Workflow.is_finished(post["uuid"]):
+        await asyncio.sleep(5)
+        if time.time() - start > timeout:
+            raise TimeoutError("Workflow timed out")
+        
+    result = rowan.Workflow.retrieve(post["uuid"])
+    
+    sorted_data = sorted(zip(result["object_data"]["energies"], result["object_data"]["conformer_uuids"]), key=lambda x: x[0])
+
+    if len(sorted_data) < num_conformers:
+        logging.warning("Number of conformers requested is greater than number of conformers available")
+    num_conformers = min(num_conformers, len(sorted_data))
+    
+    # Extract the UUIDs of the lowest n energies
+    lowest_n_uuids = [item[1][0] for item in sorted_data[:num_conformers]]
+    lowest_energies = [item[0] for item in sorted_data[:num_conformers]]
+    
+    AllChem.EmbedMultipleConfs(mol, numConfs=num_conformers)
+    
+    for i, conformer in enumerate(mol.GetConformers()):
+        atoms = rowan.Calculation.retrieve(lowest_n_uuids[i])["molecules"][-1]["atoms"]
+        pos = [atom["position"] for atom in atoms]
+        conformer.SetPositions(np.array(pos))
+        
+    return_dict = {"rdkit_molecule": mol}
+    
+    if return_energies:
+        return_dict["energies"] = lowest_energies
+
+    return return_dict

rowan/utils.py

@@ -2,9 +2,13 @@ import os
 import cctk
 import stjames
 import numpy as np
+from contextlib import contextmanager
+import httpx
 
 import rowan
 
+from .constants import API_URL
+
 
 def get_api_key() -> str:
     api_key = os.environ.get("ROWAN_API_KEY")
@@ -24,10 +28,27 @@ def cctk_to_stjames(molecule: cctk.Molecule) -> stjames.Molecule:
 
     atoms = list()
     for i in range(molecule.num_atoms()):
-        atoms.append(stjames.Atom(atomic_number=atomic_numbers[i], position=geometry[i]))
+        atoms.append(
+            stjames.Atom(atomic_number=atomic_numbers[i], position=geometry[i])
+        )
 
     return stjames.Molecule(
         atoms=atoms,
         charge=molecule.charge,
         multiplicity=molecule.multiplicity,
     )
+
+
+def smiles_to_stjames(smiles: str) -> stjames.Molecule:
+    cmol = cctk.Molecule.new_from_smiles(smiles)
+    return cctk_to_stjames(cmol)
+
+
+@contextmanager
+def api_client():
+    """Wraps `httpx.Client` with Rowan-specific kwargs."""
+    with httpx.Client(
+        base_url=API_URL,
+        headers={"X-API-Key": get_api_key()},
+    ) as client:
+        yield client

rowan/workflow.py

@@ -0,0 +1,139 @@
+import stjames
+from typing import Optional
+
+
+from .utils import api_client
+
+
+class Workflow:
+    @classmethod
+    def submit(
+        cls,
+        workflow_type: str,
+        initial_molecule: dict | stjames.Molecule,
+        workflow_data: dict,
+        name: Optional[str] = None,
+        folder_uuid: Optional[stjames.UUID] = None,
+    ) -> dict:
+        if isinstance(initial_molecule, stjames.Molecule):
+            molecule_dict = initial_molecule.model_dump()
+        elif isinstance(initial_molecule, dict):
+            molecule_dict = initial_molecule
+        else:
+            raise ValueError("Invalid type for `initial_molecule`")
+
+        with api_client() as client:
+            response = client.post(
+                "/workflow",
+                json={
+                    "name": name,
+                    "folder_uuid": folder_uuid,
+                    "initial_molecule": molecule_dict,
+                    "workflow_type": workflow_type,
+                    "workflow_data": workflow_data,
+                },
+            )
+            response.raise_for_status()
+            return response.json()
+
+    @classmethod
+    def retrieve(cls, uuid: stjames.UUID) -> dict:
+        with api_client() as client:
+            response = client.get(f"/workflow/{uuid}")
+            response.raise_for_status()
+            return response.json()
+
+    @classmethod
+    def update(
+        cls,
+        uuid: stjames.UUID,
+        name: Optional[str] = None,
+        parent_uuid: Optional[stjames.UUID] = None,
+        notes: Optional[str] = None,
+        starred: Optional[bool] = None,
+        email_when_complete: Optional[bool] = None,
+        public: Optional[bool] = None,
+    ) -> None:
+        old_data = cls.retrieve(uuid)
+
+        new_data = {}
+        new_data["name"] = name if name is not None else old_data["name"]
+        new_data["parent_uuid"] = (
+            parent_uuid if parent_uuid is not None else old_data["parent_uuid"]
+        )
+        new_data["notes"] = notes if notes is not None else old_data["notes"]
+        new_data["starred"] = starred if starred is not None else old_data["starred"]
+        new_data["email_when_complete"] = (
+            email_when_complete
+            if email_when_complete is not None
+            else old_data["email_when_complete"]
+        )
+        new_data["public"] = public if public is not None else old_data["public"]
+
+        with api_client() as client:
+            response = client.post(f"/workflow/{uuid}", json=new_data)
+            response.raise_for_status()
+            return response.json()
+
+    @classmethod
+    def status(cls, uuid: stjames.UUID) -> int:
+        data = cls.retrieve(uuid)
+        return data["object_status"]
+
+    @classmethod
+    def is_finished(cls, uuid: stjames.UUID) -> bool:
+        status = cls.status(uuid)
+        return status in {
+            stjames.Status.COMPLETED_OK.value,
+            stjames.Status.FAILED.value,
+            stjames.Status.STOPPED.value,
+        }
+
+    @classmethod
+    def stop(cls, uuid: stjames.UUID) -> None:
+        with api_client() as client:
+            response = client.post(f"/workflow/{uuid}/stop")
+            response.raise_for_status()
+
+    @classmethod
+    def delete(cls, uuid: stjames.UUID) -> None:
+        with api_client() as client:
+            response = client.delete(f"/workflow/{uuid}")
+            response.raise_for_status()
+
+    @classmethod
+    def list(
+        cls,
+        parent_uuid: Optional[stjames.UUID] = None,
+        name_contains: Optional[str] = None,
+        public: Optional[bool] = None,
+        starred: Optional[bool] = None,
+        object_status: Optional[int] = None,
+        object_type: Optional[str] = None,
+        page: int = 0,
+        size: int = 10,
+    ):
+        params = {"page": page, "size": size}
+
+        if parent_uuid is not None:
+            params["parent_uuid"] = parent_uuid
+
+        if name_contains is not None:
+            params["name_contains"] = name_contains
+
+        if public is not None:
+            params["public"] = public
+
+        if starred is not None:
+            params["starred"] = starred
+
+        if object_status is not None:
+            params["object_status"] = object_status
+
+        if object_type is not None:
+            params["object_type"] = object_type
+
+        with api_client() as client:
+            response = client.get("/workflow", params=params)
+            response.raise_for_status()
+            return response.json()

{rowan_python-0.0.5.dist-info → rowan_python-1.1.0.dist-info}/METADATA

@@ -1,22 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: rowan-python
-Version: 0.0.5
+Version: 1.1.0
 Summary: Rowan Python Library
-Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/rowan-client
 Project-URL: Bug Tracker, https://github.com/rowansci/rowan-client/issues
+Author-email: Corin Wagen <corin@rowansci.com>
+License-File: LICENSE
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: cctk >=0.2.18
-Requires-Dist: httpx >=0.25
-Requires-Dist: numpy >=1.24
-Requires-Dist: stjames >=0.0.23
 
 # Rowan Python Library
 
 [![pypi](https://img.shields.io/pypi/v/rowan-python.svg)](https://pypi.python.org/pypi/rowan-python)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
+[![pixi](https://img.shields.io/badge/Powered_by-Pixi-facc15)](https://pixi.sh)
+[![ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v1.json)](https://github.com/charliermarsh/ruff)
 
 The Rowan Python library provides convenient access to the Rowan API from applications written in the Python language.
 

rowan_python-1.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+rowan/__init__.py,sha256=9JmdQXDkbru5WDq4Slt-XWH2OP4888rYyhIoLQfKqGw,183
+rowan/calculation.py,sha256=fdWbVF97bZ2BQOBEBERLmU8DpeFUrwkZttWDSMYqwk8,312
+rowan/client.py,sha256=GQYwqZ3pZv7vH3QvfHKEWqLPklbr1QHbZtjKRpRmiIs,1282
+rowan/constants.py,sha256=ZZvv3L0b2y3dMGlWGeaRmx40J5tBrpxNxvJgjP1TNjg,37
+rowan/folder.py,sha256=W7-YnPxugqzIdw-t1sr-WjeSQa-x4IjZ2mV2DwIq3II,2965
+rowan/utils.py,sha256=IMACnRJpjFns_DF-FZQDu8p8fbgu4C2dbDaxdGcSZQs,1405
+rowan/workflow.py,sha256=An3CW9LlHxYByE4mRl1iYThYcIGry8TwTi5rgbAsEBc,4467
+rowan/rowan_rdkit/__init__.py,sha256=31bFO_UzagQKXQlybrPc2wdFJ6lUGMmDzDqT-D6b0Fk,300
+rowan/rowan_rdkit/chem_utils.py,sha256=3MRMuwi6PIr_xkKmswfMlB7P7qdJgSQs-Q3YVhGh4LY,22438
+rowan_python-1.1.0.dist-info/METADATA,sha256=CKyKYywsk9M48GAZ6Rjk_Z7qjb6YpDkSti9AuOzOXl8,1030
+rowan_python-1.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rowan_python-1.1.0.dist-info/licenses/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
+rowan_python-1.1.0.dist-info/RECORD,,

{rowan_python-0.0.5.dist-info → rowan_python-1.1.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

rowan_python-0.0.5.dist-info/RECORD

@@ -1,8 +0,0 @@
-rowan/__init__.py,sha256=0O7Cmo2Io01Uqqx9iL8xcWW0t0YfgwBX7RKxDPXnbVU,61
-rowan/client.py,sha256=HoJ7DWxpeHyMdnokKK9M3jTCqEGcwIwHmpa5EFkHg0g,5591
-rowan/utils.py,sha256=AVldYWowm7g1Ffs7JhJY7X85goNuFHvMUel0zXguDrk,932
-rowan_python-0.0.5.dist-info/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
-rowan_python-0.0.5.dist-info/METADATA,sha256=Adimw59X6Bd1-Kp_B9qM-hEWwHtxame5-epgi1MG0ec,1067
-rowan_python-0.0.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-rowan_python-0.0.5.dist-info/top_level.txt,sha256=0B0BJ1GvTwD5rxpsHctrermP7PVk4SFaQb2syJpGQl8,6
-rowan_python-0.0.5.dist-info/RECORD,,

rowan_python-0.0.5.dist-info/top_level.txt

@@ -1 +0,0 @@
-rowan