rowan-python 1.1.2__py3-none-any.whl → 1.1.5__py3-none-any.whl

rowan/rowan_rdkit/__init__.py

@@ -1,5 +1,5 @@
 from .chem_utils import (run_pka, run_tautomers, run_conformers, run_energy, 
-run_optimize, run_batch_pka, run_batch_tautomers, run_batch_energy, run_batch_optimize, run_batch_conformers)
+run_optimize, batch_pka, batch_tautomers, batch_energy, batch_optimize, batch_conformers, run_charges, batch_charges)
 
 __all__ = ["run_pka", "run_tautomers", "run_energy", "run_conformers", "run_optimize", 
-           "run_batch_pka", "run_batch_tautomers", "run_batch_energy", "run_batch_optimize",  "run_batch_conformers"]
+           "batch_pka", "batch_tautomers", "batch_energy", "batch_optimize",  "batch_conformers", "run_charges", "batch_charges"]

rowan/rowan_rdkit/chem_utils.py

@@ -5,7 +5,6 @@ import rowan
 import copy
 import asyncio
 import logging
-import math
 from rowan.utils import get_api_key
 import stjames
 import time
@@ -91,7 +90,7 @@ def run_pka(mol: RdkitMol,
         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 run_batch_pka(mols: List[RdkitMol],
+def batch_pka(mols: List[RdkitMol],
         mode: pKaMode = "rapid",
         timeout: int = 600,
         name: str = "pKa API Workflow",
@@ -99,14 +98,14 @@ def run_batch_pka(mols: List[RdkitMol],
         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 _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,
@@ -180,7 +179,7 @@ def run_tautomers(mol: RdkitMol,
     """
     return asyncio.run(_single_tautomers(mol, mode, timeout, name, folder_uuid))
 
-def run_batch_tautomers(mols: List[RdkitMol],
+def batch_tautomers(mols: List[RdkitMol],
               mode: TautomerMode = "reckless",
               timeout: int = 600,
               name: str = "Tautomers API Workflow",
@@ -190,11 +189,13 @@ def run_batch_tautomers(mols: List[RdkitMol],
     :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 _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,
@@ -257,7 +258,7 @@ def run_energy(
     """
     return asyncio.run(_single_energy(mol, method, engine, mode, timeout, name, folder_uuid))
 
-def run_batch_energy(
+def batch_energy(
     mols: List[RdkitMol],
     method: str = "aimnet2_wb97md3",
     engine: str = "aimnet2",
@@ -274,11 +275,13 @@ def run_batch_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 _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,
@@ -373,7 +376,7 @@ def run_optimize(
     """
     return asyncio.run(_single_optimize(mol, method, engine, mode, return_energies, timeout, name, folder_uuid))
 
-def run_batch_optimize(
+def batch_optimize(
     mols: List[RdkitMol],
     method: str = "aimnet2_wb97md3",
     engine: str = "aimnet2",
@@ -393,11 +396,13 @@ def run_batch_optimize(
     :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 _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,
@@ -501,7 +506,7 @@ def run_conformers(mol: RdkitMol, num_conformers=10,
     """
     return asyncio.run(_single_conformers(mol, num_conformers, method, mode, return_energies, timeout, name, folder_uuid))
 
-def run_batch_conformers(mols: List[RdkitMol], num_conformers=10,
+def batch_conformers(mols: List[RdkitMol], num_conformers=10,
                method: str = "aimnet2_wb97md3",
                mode: str = "rapid",
                return_energies: bool = False,
@@ -514,11 +519,13 @@ def run_batch_conformers(mols: List[RdkitMol], num_conformers=10,
     :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 _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,
@@ -608,3 +615,121 @@ async def _single_conformers(mol: RdkitMol, num_conformers=10,
         return_dict["energies"] = lowest_energies
 
     return return_dict
+
+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: Optional[stjames.UUID] = None
+):
+    """
+    Computes atom-centered charges 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 charges and the conformer index
+    """
+    return asyncio.run(_single_charges(mol, method, engine, mode, timeout, name, folder_uuid))
+
+def batch_charges(
+    mols: List[RdkitMol],
+    method: str = "aimnet2_wb97md3",
+    engine: str = "aimnet2",
+    mode: str = "auto",
+    timeout: int = 600,
+    name: str = "Charges 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 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: 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
+    :param engine: the engine
+    :param mode:
+    :param timeout: the timeout in seconds
+    :raises: MethodTooSlowError if the method is invalid
+    :returns: a dictionary with the charges 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": [
+                            "charge"
+                        ],
+                        "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]
+    charges_list = [rowan.Calculation.retrieve(workflow["object_data"]["calculation_uuid"])["molecules"][-1]["mulliken_charges"] for workflow in workflow_results]
+
+    return [{"conformer_index": index, "charges": charges} for index, charges in enumerate(charges_list)]
+ 

{rowan_python-1.1.2.dist-info → rowan_python-1.1.5.dist-info}/METADATA

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

{rowan_python-1.1.2.dist-info → rowan_python-1.1.5.dist-info}/RECORD

@@ -5,9 +5,9 @@ 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=BfKNC7Ts_Gay-A6FzElwg8UM4fxSapCLzeKwr7_HZNs,395
-rowan/rowan_rdkit/chem_utils.py,sha256=mVBE_OPGSPwEX_nhsJ43fIBAbdiQMTvYVHEQ9gCf0-M,22493
-rowan_python-1.1.2.dist-info/METADATA,sha256=u7oIN6zws1JHthPcb8l818KoLcXFSYXsXxyeRbq7wO8,1030
-rowan_python-1.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rowan_python-1.1.2.dist-info/licenses/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
-rowan_python-1.1.2.dist-info/RECORD,,
+rowan/rowan_rdkit/__init__.py,sha256=AGoN4fbsSbKGfeke4bPvEfgeBAM4PaasAPIILonIeBU,415
+rowan/rowan_rdkit/chem_utils.py,sha256=nbvOAEKfCStiaSi-NpxqU5C9BQrLwTMNWtd7v9DpkYw,26360
+rowan_python-1.1.5.dist-info/METADATA,sha256=2GNrC93mhprXn0HipCO_3k5lbdsmbLFwYTM8uga_X0I,1030
+rowan_python-1.1.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+rowan_python-1.1.5.dist-info/licenses/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
+rowan_python-1.1.5.dist-info/RECORD,,