rowan-python 0.0.5__py3-none-any.whl → 1.0.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/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.0.0.dist-info}/METADATA

@@ -1,22 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: rowan-python
-Version: 0.0.5
+Version: 1.0.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.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+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_python-1.0.0.dist-info/METADATA,sha256=IgayeoNx2nNIrsHExXgGMUW7hJDArdRdK5rkZ4ro_Xs,1030
+rowan_python-1.0.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+rowan_python-1.0.0.dist-info/licenses/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
+rowan_python-1.0.0.dist-info/RECORD,,

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

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: hatchling 1.25.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