rowan-python 3.0.11__py3-none-any.whl → 3.0.12__py3-none-any.whl

{rowan_python-3.0.11.dist-info → rowan_python-3.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rowan-python
-Version: 3.0.11
+Version: 3.0.12
 Summary: Rowan Python Library
 Project-URL: Homepage, https://github.com/rowansci/rowan-client
 Project-URL: Bug Tracker, https://github.com/rowansci/rowan-client/issues

{rowan_python-3.0.11.dist-info → rowan_python-3.0.12.dist-info}/RECORD

@@ -11,8 +11,6 @@ rowan/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rowan/types.py,sha256=rCAnUlCsemyBK9Bbus0pL-THoqNqJIQHaMoDferIfFU,471
 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=CM3GKDTafp6vl79dWqSOvkVfwH1Ty8zuc8yzi65ABxM,4438
 rowan/workflows/admet.py,sha256=0_wIwXXLfHF-3kgGx_1EM1ljjaYHLeEijJ-GbMYxpL8,2904
 rowan/workflows/analogue_docking.py,sha256=LJpbbaug0tZ9Cg-m0b7EgGH5hJ5894fHOC16Wefx7mE,9206
@@ -51,7 +49,7 @@ rowan/workflows/solvent_dependent_conformers.py,sha256=ovvnhCE4xlkpdhccLHEq7oBJR
 rowan/workflows/spin_states.py,sha256=c0y2cwO9NE8DmxmQ9ZouA5QoBhxgZiTYFIqhC-geVAo,7382
 rowan/workflows/strain.py,sha256=N-CoOT-hjYzjYTMYR9Uzoy4EhnrLQEOeDNSNphsUIXQ,6380
 rowan/workflows/tautomer_search.py,sha256=GB96BjvVsJDgLCTH4S4nkAlBoCvKud_18Y3PTY9Q528,5779
-rowan_python-3.0.11.dist-info/METADATA,sha256=YvbKSL7wGaXuiFFHhnXUEvUvLj0G6Dx-HXOY5kw8X3I,1601
-rowan_python-3.0.11.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-rowan_python-3.0.11.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
-rowan_python-3.0.11.dist-info/RECORD,,
+rowan_python-3.0.12.dist-info/METADATA,sha256=0pcHHITAsvBIWYCiohdeX3Tc11wdjBMa81rTkyuxI8M,1601
+rowan_python-3.0.12.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+rowan_python-3.0.12.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
+rowan_python-3.0.12.dist-info/RECORD,,

rowan/rowan_rdkit/__init__.py

@@ -1,29 +0,0 @@
-from .chem_utils import (
-    batch_charges,
-    batch_conformers,
-    batch_energy,
-    batch_optimize,
-    batch_pka,
-    batch_tautomers,
-    run_charges,
-    run_conformers,
-    run_energy,
-    run_optimize,
-    run_pka,
-    run_tautomers,
-)
-
-__all__ = [
-    "batch_charges",
-    "batch_conformers",
-    "batch_energy",
-    "batch_optimize",
-    "batch_pka",
-    "batch_tautomers",
-    "run_charges",
-    "run_conformers",
-    "run_energy",
-    "run_optimize",
-    "run_pka",
-    "run_tautomers",
-]

rowan/rowan_rdkit/chem_utils.py

@@ -1,1019 +0,0 @@
-import asyncio
-import copy
-import logging
-import time
-from typing import Iterable, Literal, TypedDict
-
-import numpy as np
-import stjames
-from rdkit import Chem
-from rdkit.Chem import AllChem
-
-import rowan
-from rowan.types import RdkitMol
-from rowan.utils import ATOMIC_NUMBER_TO_ATOMIC_SYMBOL, get_api_key
-
-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
-
-
-class ChargesResult(TypedDict):
-    conformer_index: int
-    charges: list[float]
-
-
-ChargesResults = list[ChargesResult]
-
-
-class ConformerResult(TypedDict):
-    molecule: RdkitMol
-    energies: list[float]
-
-
-class PKaResult(TypedDict):
-    element: str
-    index: int
-    pKa: float
-
-
-class PKaResults(TypedDict):
-    acidic_pkas: list[PKaResult]
-    basic_pkas: list[PKaResult]
-
-
-class TautomerResult(TypedDict):
-    molecule: RdkitMol
-    predicted_relative_energy: float
-    weight: float
-
-
-TautomerResults = list[TautomerResult]
-
-
-class ConformerEnergyResult(TypedDict):
-    conformer_index: int
-    energy: float
-
-
-class OptimizeResult(TypedDict):
-    molecule: RdkitMol
-    energies: list[float]
-
-
-def apply_nest_asyncio() -> None:
-    try:
-        asyncio.get_running_loop()
-    except RuntimeError:
-        return
-    try:
-        import nest_asyncio  # type: ignore [import-untyped]
-
-        nest_asyncio.apply()
-    except ImportError:
-        pass
-
-
-# actually apply it
-apply_nest_asyncio()
-
-
-def _get_rdkit_mol_from_uuid(calculation_uuid: str) -> RdkitMol:
-    calc = rowan.retrieve_calculation(calculation_uuid)
-    if calc.molecule is None:
-        raise ValueError(f"Calculation {calculation_uuid} has no molecules")
-    return Chem.MolFromXYZBlock(calc.molecule.to_xyz())  # type: ignore[attr-defined]
-
-
-def _embed_rdkit_mol(rdkm: RdkitMol) -> RdkitMol:
-    try:
-        AllChem.SanitizeMol(rdkm)  # type: ignore[attr-defined]
-    except Exception as e:
-        raise ValueError("Molecule could not be generated -- invalid chemistry!") from e
-
-    rdkm = AllChem.AddHs(rdkm)  # type: ignore[attr-defined]
-    try:
-        assert AllChem.EmbedMolecule(rdkm, maxAttempts=200) >= 0  # type: ignore[attr-defined]
-    except AssertionError as e:
-        status1 = AllChem.EmbedMolecule(rdkm, maxAttempts=200, useRandomCoords=True)  # type: ignore[attr-defined]
-        if status1 < 0:
-            raise ValueError("Cannot embed molecule!") from e
-    try:
-        assert AllChem.MMFFOptimizeMolecule(rdkm, maxIters=200) >= 0  # type: ignore[attr-defined, call-arg]
-    except AssertionError:
-        pass
-
-    return rdkm
-
-
-def _rdkit_to_stjames(rdkm: RdkitMol, cid: int = 0) -> stjames.Molecule:
-    return stjames.Molecule.from_rdkit(rdkm, cid=cid)
-
-
-def run_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] | None = None,
-    protonate_elements: list[int] | None = None,
-    folder_uuid: str | None = None,
-) -> PKaResults:
-    """
-    Calculate the pKa of a Molecule.
-
-    :param mol: RDKit Molecule
-    :param mode: pKa calculation Mode. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param pka_range: range of pKa values to calculate
-    :param deprotonate_elements: elements to deprotonate
-    :param protonate_elements: elements to protonate
-    :param folder_uuid: folder UUID
-    :returns: dictionary of pKa values indexed by atom
-    """
-    protonate_elements = protonate_elements or [7]
-    deprotonate_elements = deprotonate_elements or [7, 8, 16]
-
-    return asyncio.run(
-        _single_pka(
-            mol,
-            mode,
-            timeout,
-            name,
-            pka_range,
-            deprotonate_elements,
-            protonate_elements,
-            folder_uuid,
-        )
-    )
-
-
-def batch_pka(
-    mols: Iterable[RdkitMol],
-    mode: pKaMode = "rapid",
-    timeout: int = 600,
-    name: str = "pKa API Workflow",
-    pka_range: tuple[int, int] = (2, 12),
-    deprotonate_elements: list[int] | None = None,
-    protonate_elements: list[int] | None = None,
-    folder_uuid: str | None = None,
-) -> list[PKaResults]:
-    """
-    Calculate the pKa of a batch of Molecules.
-
-    :param mols: list of RDKit Molecules
-    :param mode: pKa calculation mode. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param pka_range: range of pKa values to calculate
-    :param deprotonate_elements: elements to deprotonate
-    :param protonate_elements: elements to protonate
-    :returns: list of dictionary of pKa values indexed by atom
-    """
-    protonate_elements = protonate_elements or [7]
-    deprotonate_elements = deprotonate_elements or [7, 8, 16]
-
-    async def _run():
-        tasks = [
-            _single_pka(
-                mol,
-                mode,
-                timeout,
-                name,
-                pka_range,
-                deprotonate_elements,
-                protonate_elements,
-                folder_uuid,
-            )
-            for mol in mols
-        ]
-        return await asyncio.gather(*tasks)
-
-    return asyncio.run(_run())
-
-
-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] | None = None,
-    protonate_elements: list[int] | None = None,
-    folder_uuid: str | None = None,
-) -> PKaResults:
-    """
-    Calculate the pKa of a Molecule.
-
-    :param mol: RDKit Molecule
-    :param mode: pKa calculation mode. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param pka_range: range of pKa values to calculate
-    :param deprotonate_elements: elements to deprotonate
-    :param protonate_elements: elements to protonate
-    :param folder_uuid: folder UUID
-    :returns: dictionary of pKa values
-    """
-    get_api_key()
-    protonate_elements = protonate_elements or [7]
-    deprotonate_elements = deprotonate_elements or [7, 8, 16]
-
-    post = rowan.submit_workflow(
-        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 post.is_finished():
-        await asyncio.sleep(5)
-        if time.time() - start > timeout:
-            raise TimeoutError("Workflow timed out")
-
-    data = rowan.retrieve_workflow(post.uuid).data
-
-    if not data:
-        raise Exception("Could not retrieve workflow data")
-
-    acidic_pkas: list[PKaResult] = []
-    for microstate in data.get("conjugate_bases", []):
-        atomic_number = data.get("initial_molecule", {})["atoms"][microstate["atom_index"] - 1][
-            "atomic_number"
-        ]
-        acidic_pkas.append(
-            {
-                "element": ATOMIC_NUMBER_TO_ATOMIC_SYMBOL[str(atomic_number)],
-                "index": microstate["atom_index"],
-                "pKa": round(microstate["pka"], 2),
-            }
-        )
-
-    basic_pkas: list[PKaResult] = []
-    for microstate in data.get("conjugate_bases", []):
-        atomic_number = data.get("initial_molecule", {})["atoms"][microstate["atom_index"] - 1][
-            "atomic_number"
-        ]
-
-        basic_pkas.append(
-            {
-                "element": ATOMIC_NUMBER_TO_ATOMIC_SYMBOL[str(atomic_number)],
-                "index": microstate["atom_index"],
-                "pKa": round(microstate["pka"], 2),
-            }
-        )
-
-    return {"acidic_pkas": acidic_pkas, "basic_pkas": basic_pkas}
-
-
-def run_tautomers(
-    mol: RdkitMol,
-    mode: TautomerMode = "reckless",
-    timeout: int = 600,
-    name: str = "Tautomers API Workflow",
-    folder_uuid: str | None = None,
-) -> TautomerResults:
-    """
-    Generate possible tautomers of a Molecule.
-
-    :param mol: RDKit Molecule
-    :param mode: Tautomer mode. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :returns: list of dictionaries containing RDKit Molecule, relative energies, and weights
-    """
-    return asyncio.run(_single_tautomers(mol, mode, timeout, name, folder_uuid))
-
-
-def batch_tautomers(
-    mols: Iterable[RdkitMol],
-    mode: TautomerMode = "reckless",
-    timeout: int = 600,
-    name: str = "Tautomers API Workflow",
-    folder_uuid: str | None = None,
-) -> list[TautomerResults]:
-    """
-    Generate possible tautomers of a Molecule.
-
-    :param mols: RDKit Molecule
-    :param mode: Tautomer mode. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :returns: List of lists of dicts containing RDKit Molecule, relative energies, and weights.
-    """
-
-    async def _run():
-        tasks = [_single_tautomers(mol, mode, timeout, name, folder_uuid) for mol in mols]
-        return await asyncio.gather(*tasks)
-
-    return asyncio.run(_run())
-
-
-async def _single_tautomers(
-    mol: RdkitMol,
-    mode: TautomerMode = "reckless",
-    timeout: int = 600,
-    name: str = "Tautomers API Workflow",
-    folder_uuid: str | None = None,
-) -> TautomerResults:
-    """
-    Generate possible tautomers of a Molecule.
-
-    :param mol: RDKit Molecule
-    :param mode: Tautomer mode
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :returns: dictionaries containing RDKit Molecule, relative energy, and weight
-    """
-    get_api_key()
-
-    post = rowan.submit_workflow(
-        name=name,
-        workflow_type="tautomers",
-        initial_molecule=_rdkit_to_stjames(mol),
-        workflow_data={"mode": mode},
-        folder_uuid=folder_uuid,
-    )
-
-    start = time.time()
-    while not post.is_finished():
-        await asyncio.sleep(5)
-        if time.time() - start > timeout:
-            raise TimeoutError("Workflow timed out")
-
-    data = rowan.retrieve_workflow(post.uuid).data
-
-    if not data:
-        raise Exception("Could not retrieve workflow data")
-
-    return [
-        {
-            "molecule": _get_rdkit_mol_from_uuid(tautomer["structures"][0]["uuid"]),
-            "predicted_relative_energy": round(tautomer["predicted_relative_energy"], 2),
-            "weight": round(tautomer["weight"], 5),
-        }
-        for tautomer in data.get("tautomers", [])
-    ]
-
-
-def run_energy(
-    mol: RdkitMol,
-    method: str = "aimnet2_wb97md3",
-    engine: str = "aimnet2",
-    mode: str = "auto",
-    timeout: int = 600,
-    name: str = "Energy API Workflow",
-    folder_uuid: str | None = None,
-) -> list[ConformerEnergyResult]:
-    """
-    Computes the energy for the given molecule.
-
-    :param mol: RDKit Molecule
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param engine: Engine to run the energy. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
-    :param mode: Mode to run the energy. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :raises MethodTooSlowError: if the method is invalid
-    :returns: 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: Iterable[RdkitMol],
-    method: str = "aimnet2_wb97md3",
-    engine: str = "aimnet2",
-    mode: str = "auto",
-    timeout: int = 600,
-    name: str = "Energy API Workflow",
-    folder_uuid: str | None = None,
-) -> list[list[ConformerEnergyResult]]:
-    """
-    Computes the energy for the given molecule.
-
-    :param mols: RDKit Molecule
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param engine: Engine to run the energy. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
-    :param mode: Mode to run the energy. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :raises MethodTooSlowError: if the method is invalid
-    :returns: list of dictionaries with the energy in Hartree and the conformer index
-    """
-
-    async def _run():
-        tasks = [
-            _single_energy(mol, method, engine, mode, timeout, name, folder_uuid) for mol in mols
-        ]
-        return await asyncio.gather(*tasks)
-
-    return asyncio.run(_run())
-
-
-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: str | None = None,
-) -> list[ConformerEnergyResult]:
-    """
-    Computes the energy for the given molecule.
-
-    :param mol: RDKit Molecule
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param engine: Engine to run the energy. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
-    :param mode: Mode to run the energy
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :raises MethodTooSlowError: if the method is invalid
-    :returns: dictionary with the energy in Hartree and the conformer index
-    """
-    get_api_key()
-    method = stjames.Method(method)
-
-    if mol.GetNumConformers() == 0:  # type: ignore[call-arg]
-        mol = _embed_rdkit_mol(mol)
-        if mol.GetNumConformers() == 0:  # type: ignore[call-arg]
-            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()  # type: ignore[call-arg]
-        stjames_mol = _rdkit_to_stjames(mol, cid)
-        post = rowan.submit_workflow(
-            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.retrieve_workflow(uuid).is_finished() for uuid in workflow_uuids):
-        await asyncio.sleep(5)
-        if time.time() - start > timeout:
-            raise TimeoutError("Workflow timed out")
-
-    results = [rowan.retrieve_workflow(uuid).data for uuid in workflow_uuids]
-
-    energies: list[float] = []
-    for data in results:
-        if data is not None:
-            calc = rowan.retrieve_calculation(data["calculation_uuid"])
-            if calc.energy is not None:
-                energies.append(calc.energy)
-
-    return [{"conformer_index": index, "energy": energy} for index, energy in enumerate(energies)]
-
-
-def run_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: str | None = None,
-) -> OptimizeResult:
-    """
-    Optimize each of a molecule's conformers and then return the molecule.
-
-    :param mol: RDKit Molecule
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param engine: Engine to run the optimization. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
-    :param return_energies: whether to return energies in Hartree too
-    :param mode: Mode to run the optimization. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :raises MethodTooSlowError: if the method is invalid
-    :returns: dictionary with the optimized conformer(s) and optional list of energies per conformer
-    """
-    return asyncio.run(
-        _single_optimize(mol, method, engine, mode, return_energies, timeout, name, folder_uuid)
-    )
-
-
-def batch_optimize(
-    mols: Iterable[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: str | None = None,
-) -> list[OptimizeResult]:
-    """
-    Optimize each of a Molecule's conformers and then return the Molecule.
-
-    :param mols: input Molecule
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param engine: Engine to run the optimization. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
-    :param mode: Mode to run the optimization. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param return_energies: whether to return energies in Hartree too
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :raises MethodTooSlowError: if the method is invalid
-    :returns: dictionaries with optimized conformer(s) and optional list of energies per conformer
-    """
-
-    async def _run():
-        tasks = [
-            _single_optimize(mol, method, engine, mode, return_energies, timeout, name, folder_uuid)
-            for mol in mols
-        ]
-        return await asyncio.gather(*tasks)
-
-    return asyncio.run(_run())
-
-
-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: str | None = None,
-) -> OptimizeResult:
-    """
-    Optimize each of a molecule's conformers and then return the molecule.
-
-    :param mol: RDKit Molecule
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param engine: Engine to run the optimization. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
-    :param mode: Mode to run the optimization. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    :param return_energies: whether to return energies in Hartree too
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :raises MethodTooSlowError: if the method is invalid
-    :returns: dictionary with the optimized conformer(s) and optional list of energies per conformer
-    """
-    get_api_key()
-    method = stjames.Method(method)
-
-    if mol.GetNumConformers() == 0:  # type: ignore[call-arg]
-        mol = _embed_rdkit_mol(mol)
-        if mol.GetNumConformers() == 0:  # type: ignore[call-arg]
-            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()  # type: ignore[call-arg]
-        stjames_mol = _rdkit_to_stjames(mol, cid)
-
-        post = rowan.submit_workflow(
-            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.retrieve_workflow(uuid).is_finished() for uuid in workflow_uuids):
-        await asyncio.sleep(5)
-        if time.time() - start > timeout:
-            raise TimeoutError("Workflow timed out")
-
-    results = [rowan.retrieve_workflow(uuid).data for uuid in workflow_uuids]
-    calculations = [
-        rowan.retrieve_calculation(data["calculation_uuid"]) for data in results if data is not None
-    ]
-    optimized_positions: list[list[tuple[float, float, float]]] = []
-    energies: list[float] = []
-    for calc in calculations:
-        if calc.molecule is not None:
-            optimized_positions.append([atom.position for atom in calc.molecule.atoms])
-            if calc.energy is not None:
-                energies.append(calc.energy)
-
-    for i, conformer in enumerate(optimized_mol.GetConformers()):
-        conformer.SetPositions(np.array(optimized_positions[i]))  # type: ignore[attr-defined]
-
-    return {
-        "molecule": mol,
-        "energies": energies if return_energies else [],
-    }
-
-
-def run_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: str | None = None,
-) -> ConformerResult:
-    """
-    Generate conformers for a Molecule.
-
-    :param mol: RDKit Molecule
-    :param num_conformers: number of conformers to generate
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param mode: Mode for conformer generation. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param return_energies: whether to return energies in Hartree too
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :returns: dictionary with the RDKit Molecule and energies
-    """
-    return asyncio.run(
-        _single_conformers(
-            mol,
-            num_conformers,
-            method,
-            mode,
-            return_energies,
-            timeout,
-            name,
-            folder_uuid,
-        )
-    )
-
-
-def batch_conformers(
-    mols: Iterable[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: str | None = None,
-) -> list[ConformerResult]:
-    """
-    Generate conformers for a Molecule.
-
-    :param mols: RDKit molecule object
-    :param num_conformers: number of conformers to generate
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param mode: conformer generation mode. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param return_energies: whether to return energies in Hartree too
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :returns: list of dictonaries with RDKit Molecule and energies
-    """
-
-    async def _run():
-        tasks = [
-            _single_conformers(
-                mol,
-                num_conformers,
-                method,
-                mode,
-                return_energies,
-                timeout,
-                name,
-                folder_uuid,
-            )
-            for mol in mols
-        ]
-        return await asyncio.gather(*tasks)
-
-    return asyncio.run(_run())
-
-
-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: str | None = None,
-) -> ConformerResult:
-    """
-    Generate conformers for a molecule.
-
-    :param mol: RDKit Molecule
-    :param num_conformers: number of conformers to generate
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param mode: conformer generation mode. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param return_energies: whether to return energies in Hartree too
-    :param timeout: time in seconds before the Workflow times out
-    :param name: name for the job
-    :param folder_uuid: folder UUID
-    :returns: dictionary with RDKit molecule and energies
-    """
-    get_api_key()
-    method = stjames.Method(method)
-
-    if mol.GetNumConformers() == 0:  # type: ignore[call-arg]
-        mol = _embed_rdkit_mol(mol)
-        if mol.GetNumConformers() == 0:  # type: ignore[call-arg]
-            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.submit_workflow(
-        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 post.is_finished():
-        await asyncio.sleep(5)
-        if time.time() - start > timeout:
-            raise TimeoutError("Workflow timed out")
-
-    data = rowan.retrieve_workflow(post.uuid).data
-
-    if data is None:
-        raise NoConformersError("This molecule has no conformers")
-
-    sorted_data = sorted(
-        zip(data["energies"], data["conformer_uuids"], strict=True),
-        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)  # type: ignore[attr-defined]
-
-    for i, conformer in enumerate(mol.GetConformers()):
-        calc = rowan.retrieve_calculation(lowest_n_uuids[i])
-        if calc.molecule is None:
-            raise ValueError(f"Calculation {lowest_n_uuids[i]} has no molecules")
-        pos = [atom.position for atom in calc.molecule.atoms]
-        conformer.SetPositions(np.array(pos))  # type: ignore[attr-defined]
-
-    return {
-        "molecule": mol,
-        "energies": lowest_energies if return_energies else [],
-    }
-
-
-def run_charges(
-    mol: RdkitMol,
-    method: str = "aimnet2_wb97md3",
-    engine: str = "aimnet2",
-    mode: str = "auto",
-    timeout: int = 600,
-    name: str = "Charges API Workflow",
-    folder_uuid: str | None = None,
-) -> ChargesResults:
-    """
-    Computes atom-centered charges for the given Molecule.
-
-    :param mol: RDKit Molecule
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param engine: Engine to run the charges. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
-    :param mode: Mode to run the calculation in. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: timeout in seconds
-    :param name: name of the job
-    :param folder_uuid: folder UUID
-    :raises MethodTooSlowError: if the method is invalid
-    :returns: dictionary with the charges and the conformer index
-    """
-    return asyncio.run(_single_charges(mol, method, engine, mode, timeout, name, folder_uuid))
-
-
-def batch_charges(
-    mols: Iterable[RdkitMol],
-    method: str = "aimnet2_wb97md3",
-    engine: str = "aimnet2",
-    mode: str = "auto",
-    timeout: int = 600,
-    name: str = "Charges API Workflow",
-    folder_uuid: str | None = None,
-) -> list[ChargesResults]:
-    """
-    Computes atom-centered charges for the given Molecules.
-
-    :param mols: RDKit Molecule
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param engine: Engine to run the charges. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
-    :param mode: Mode to run the calculation in. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: timeout in seconds
-    :param name: name of the job
-    :param folder_uuid: folder UUID
-    :raises MethodTooSlowError: if the method is invalid
-    :returns: list of dictionaries with the charges and the conformer index
-    """
-
-    async def _run():
-        tasks = [
-            _single_charges(mol, method, engine, mode, timeout, name, folder_uuid) for mol in mols
-        ]
-        return await asyncio.gather(*tasks)
-
-    return asyncio.run(_run())
-
-
-async def _single_charges(
-    mol: RdkitMol,
-    method: str = "aimnet2_wb97md3",
-    engine: str = "aimnet2",
-    mode: str = "auto",
-    timeout: int = 600,
-    name: str = "Energy API Workflow",
-    folder_uuid: str | None = None,
-) -> ChargesResults:
-    """
-    Computes atom-centered charges for the given Molecule.
-
-    :param mol: RDKit Molecule
-    :param method: Method to use for the calculation.
-    See [list of available methods](https://github.com/rowansci/stjames-public/blob/master/stjames/method.py)
-    :param engine: Engine to run the charges. See [list of available engines](https://github.com/rowansci/stjames-public/blob/master/stjames/engine.py)
-    :param mode: Mode to run the calculation in. See [list of available modes](https://github.com/rowansci/stjames-public/blob/master/stjames/mode.py)
-    for options.
-    :param timeout: timeout in seconds
-    :param name: name of the job
-    :param folder_uuid: folder UUID
-    :raises MethodTooSlowError: if the method is invalid
-    :returns: dictionary with the charges and the conformer index
-    """
-    get_api_key()
-    method = stjames.Method(method)
-
-    if mol.GetNumConformers() == 0:  # type: ignore[call-arg]
-        mol = _embed_rdkit_mol(mol)
-        if mol.GetNumConformers() == 0:  # type: ignore[call-arg]
-            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()  # type: ignore[call-arg]
-
-        post = rowan.submit_workflow(
-            name=name,
-            workflow_type="basic_calculation",
-            initial_molecule=_rdkit_to_stjames(mol, cid),
-            workflow_data={
-                "settings": {
-                    "method": method.value,
-                    "corrections": [],
-                    "tasks": ["charge"],
-                    "mode": mode,
-                    "opt_settings": {"constraints": []},
-                },
-                "engine": engine,
-            },
-            folder_uuid=folder_uuid,
-        )
-
-        workflow_uuids.append(post.uuid)
-
-    start = time.time()
-    while not all(rowan.retrieve_workflow(uuid).is_finished() for uuid in workflow_uuids):
-        await asyncio.sleep(5)
-        if time.time() - start > timeout:
-            raise TimeoutError("Workflow timed out")
-
-    def grab_charges(uuid: str) -> list[float]:
-        """Grab mulliken charges by UUID of workflow."""
-        data = rowan.retrieve_workflow(uuid).data
-        if data is None:
-            raise KeyError("Workflow data not found")
-        calc = rowan.retrieve_calculation(data["calculation_uuid"])
-        if calc.molecule is None or calc.molecule.charges is None:
-            raise KeyError("Calculation has no charges")
-        return calc.molecule.charges
-
-    return [
-        {"conformer_index": i, "charges": grab_charges(uuid)}
-        for i, uuid in enumerate(workflow_uuids)
-    ]