stjames 0.0.114__tar.gz → 0.0.135__tar.gz

{stjames-0.0.114/stjames.egg-info → stjames-0.0.135}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stjames
-Version: 0.0.114
+Version: 0.0.135
 Summary: standardized JSON atom/molecule encoding scheme
 Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/stjames

{stjames-0.0.114 → stjames-0.0.135}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stjames"
-version = "0.0.114"
+version = "0.0.135"
 description = "standardized JSON atom/molecule encoding scheme"
 readme = "README.md"
 requires-python = ">=3.11"

{stjames-0.0.114 → stjames-0.0.135}/stjames/__init__.py

@@ -22,3 +22,4 @@ from .status import *
 from .constraint import *
 from .message import *
 from .types import *
+from .engine import *

{stjames-0.0.114 → stjames-0.0.135}/stjames/atomium_stjames/mmcif.py

@@ -512,7 +512,7 @@ def add_atom_to_polymer(atom: dict[str, Any], aniso: dict[int, Any], model: dict
     try:
         model["polymer"][mol_id]["residues"][res_id]["atoms"][int(atom["id"])] = atom_dict_to_atom_dict(atom, aniso)
     except Exception:
-        name = atom["auth_comp_id"]
+        name = atom.get("auth_comp_id") or atom.get("label_comp_id") or "UNKNOWN"
         try:
             model["polymer"][mol_id]["residues"][res_id] = {
                 "name": name,
@@ -553,7 +553,7 @@ def add_atom_to_non_polymer(atom: dict[str, Any], aniso: dict[int, Any], model:
     try:
         model[mol_type][mol_id]["atoms"][int(atom["id"])] = atom_dict_to_atom_dict(atom, aniso)
     except Exception:
-        name = atom["auth_comp_id"]
+        name = atom.get("auth_comp_id") or atom.get("label_comp_id") or "UNKNOWN"
         model[mol_type][mol_id] = {
             "name": name,
             "full_name": names.get(name).upper() if names.get(name) is not None and names.get(name).lower() != "water" else None,  # type: ignore [union-attr]

{stjames-0.0.114 → stjames-0.0.135}/stjames/atomium_stjames/pdb.py

@@ -321,7 +321,7 @@ def assembly_lines_to_assembly_dict(lines: list[str]) -> dict[str, Any]:
         (r"(.+)AREA OF THE COMPLEX: (.+) [A-Z]", "surface_area", float),
         (r"(.+)FREE ENERGY: (.+) [A-Z]", "delta_energy", float),
     ]
-    t = None
+    t: Any = None
     for line in lines:
         for pattern, key, converter in patterns:
             matches = re.findall(pattern, line)

{stjames-0.0.114 → stjames-0.0.135}/stjames/calculation.py

@@ -1,10 +1,13 @@
-from typing import Optional
+from typing import Optional, Self
 
-from .base import Base, LowercaseStrEnum
+from pydantic import model_validator
+
+from .base import Base, LowercaseStrEnum, UniqueList
 from .message import Message
 from .molecule import Molecule
 from .settings import Settings
 from .status import Status
+from .task import Task
 from .types import UUID
 
 
@@ -20,6 +23,7 @@ class StJamesVersion(LowercaseStrEnum):
 class Calculation(Base):
     molecules: list[Molecule]
 
+    tasks: UniqueList[Task] = []
     settings: Settings = Settings()
 
     status: Status = Status.QUEUED
@@ -29,8 +33,17 @@ class Calculation(Base):
     logfile: Optional[str] = None
     messages: list[Message] = []
 
+    # DEPRECATED - moving into settings
     engine: Optional[str] = "peregrine"
+
     uuids: list[UUID | None] | None = None
 
     # not to be changed by end users, diff. versions will have diff. defaults
     json_format: str = StJamesVersion.V0
+
+    @model_validator(mode="after")
+    def populate_tasks(self) -> Self:
+        """Set the tasks from the settings, so that we don't have to migrate old entries."""
+        if len(self.tasks) == 0:
+            self.tasks = self.settings.tasks
+        return self

stjames-0.0.135/stjames/dna.py

@@ -0,0 +1,13 @@
+"""DNA-related data models."""
+
+from .base import Base
+
+
+class DNASequence(Base):
+    """
+    DNA sequence data.
+
+    :param sequence: nucleotide string
+    """
+
+    sequence: str

{stjames-0.0.114 → stjames-0.0.135}/stjames/engine.py

@@ -9,6 +9,7 @@ class Engine(LowercaseStrEnum):
     TBLITE = "tblite"
     XTB = "xtb"
     TERACHEM = "terachem"
+    GPU4PYSCF = "gpu4pyscf"
     PYSCF = "pyscf"
     PSI4 = "psi4"
     OPENFF = "openff"

{stjames-0.0.114 → stjames-0.0.135}/stjames/method.py

@@ -65,6 +65,7 @@ class Method(LowercaseStrEnum):
 
     # Force fields
     OFF_SAGE_2_2_1 = "off_sage_2_2_1"
+    SMIRNOFF_2_2_1_AMBER_AM1BCC = "smirnoff_2_2_1_amber_am1bcc"
 
     def default_engine(self, *, is_periodic: bool = False) -> Engine:
         """
@@ -93,7 +94,7 @@ class Method(LowercaseStrEnum):
                 return Engine.ORB
             case method if method in XTB_METHODS:
                 return Engine.TBLITE if is_periodic else Engine.XTB
-            case Method.OFF_SAGE_2_2_1:
+            case Method.OFF_SAGE_2_2_1 | Method.SMIRNOFF_2_2_1_AMBER_AM1BCC:
                 return Engine.OPENFF
             case Method.EGRET_1 | Method.EGRET_1E | Method.EGRET_1T:
                 return Engine.EGRET
@@ -140,8 +141,8 @@ XTB_METHODS = [Method.GFN_FF, Method.GFN0_XTB, Method.GFN1_XTB, Method.GFN2_XTB,
 CompositeMethod = Literal[Method.HF3C, Method.B973C, Method.R2SCAN3C, Method.WB97X3C]
 COMPOSITE_METHODS = [Method.HF3C, Method.B973C, Method.R2SCAN3C, Method.WB97X3C]
 
-FFMethod = Literal[Method.OFF_SAGE_2_2_1]
-FF_METHODS = [Method.OFF_SAGE_2_2_1]
+FFMethod = Literal[Method.OFF_SAGE_2_2_1, Method.SMIRNOFF_2_2_1_AMBER_AM1BCC]
+FF_METHODS = [Method.OFF_SAGE_2_2_1, Method.SMIRNOFF_2_2_1_AMBER_AM1BCC]
 
 PrepackagedMethod = XTBMethod | CompositeMethod | PrepackagedNNPMethod | FFMethod
 PREPACKAGED_METHODS = [*XTB_METHODS, *COMPOSITE_METHODS, *PREPACKAGED_NNP_METHODS, *FF_METHODS]

{stjames-0.0.114 → stjames-0.0.135}/stjames/molecule.py

@@ -1,3 +1,4 @@
+import logging
 import re
 from pathlib import Path
 from typing import Annotated, Any, Iterable, Optional, Self, Sequence, TypeAlias, TypedDict, TypeVar
@@ -26,6 +27,8 @@ from .types import (
 
 RdkitMol: TypeAlias = Chem.rdchem.Mol | Chem.rdchem.RWMol
 
+logger = logging.getLogger(__name__)
+
 
 class MoleculeReadError(RuntimeError):
     pass
@@ -123,7 +126,7 @@ class Molecule(Base):
         >>> mol = Molecule.from_xyz("H 0 0 0\nH 0 0 1")
         >>> print(mol.translated((1, 0, 0)).to_xyz())
         2
-        <BLANKLINE>
+        charge: 0; multiplicity: 1;
         H     1.0000000000    0.0000000000    0.0000000000
         H     1.0000000000    0.0000000000    1.0000000000
         """
@@ -131,9 +134,9 @@ class Molecule(Base):
         def translated(position: Vector3D) -> Vector3D:
             return tuple(q + v for q, v in zip(position, vector, strict=True))  # type: ignore [return-value]
 
-        atoms = [atom.copy(update={"position": translated(atom.position)}) for atom in self.atoms]
+        atoms = [atom.model_copy(update={"position": translated(atom.position)}) for atom in self.atoms]
 
-        return self.copy(update={"atoms": atoms})
+        return self.model_copy(update={"atoms": atoms})
 
     @property
     def atomic_numbers(self) -> list[NonNegativeInt]:
@@ -184,7 +187,7 @@ class Molecule(Base):
         return self
 
     @classmethod
-    def from_file(cls: type[Self], filename: Path | str, format: str | None = None, charge: int = 0, multiplicity: PositiveInt = 1) -> Self:
+    def from_file(cls: type[Self], filename: Path | str, format: str | None = None, charge: int | None = None, multiplicity: PositiveInt | None = None) -> Self:
         r"""
         Read a molecule from a file.
 
@@ -195,7 +198,7 @@ class Molecule(Base):
         ...    mol = Molecule.from_file(f.name)
         >>> print(mol.to_xyz())
         2
-        <BLANKLINE>
+        charge: 0; multiplicity: 1;
         H     0.0000000000    0.0000000000    0.0000000000
         F     0.0000000000    0.0000000000    1.0000000000
         """
@@ -213,7 +216,7 @@ class Molecule(Base):
                     raise ValueError(f"Unsupported {format=}")
 
     @classmethod
-    def from_xyz(cls: type[Self], xyz: str, charge: int = 0, multiplicity: PositiveInt = 1) -> Self:
+    def from_xyz(cls: type[Self], xyz: str, charge: int | None = None, multiplicity: PositiveInt | None = None) -> Self:
         r"""
         Generate a Molecule from an XYZ string.
 
@@ -225,38 +228,113 @@ class Molecule(Base):
         return cls.from_xyz_lines(xyz.strip().splitlines(), charge=charge, multiplicity=multiplicity)
 
     @classmethod
-    def from_xyz_lines(cls: type[Self], lines: Iterable[str], charge: int = 0, multiplicity: PositiveInt = 1) -> Self:
+    def from_xyz_lines(cls: type[Self], lines: Iterable[str], charge: int | None = None, multiplicity: PositiveInt | None = None) -> Self:
+        r"""
+        Read a molecule from a xyz lines.
+
+        >>> mol = Molecule.from_xyz_lines(["2", "charge: 0; multiplicity: 1; cell: [[1, 2e1, 3], [4, 5, 6], [7, 8, 9.1]]", "H 0 0 0", "F 0 0 1"])
+        >>> print(mol.to_xyz())
+        2
+        charge: 0; multiplicity: 1; cell: ((1.0, 20.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.1)); is_periodic: (True, True, True);
+        H     0.0000000000    0.0000000000    0.0000000000
+        F     0.0000000000    0.0000000000    1.0000000000
+        >>> mol = Molecule.from_xyz_lines(["2", "energy: abc", "H 0 0 0", "F 0 0 1"])
+        >>> print(mol.to_xyz())
+        2
+        charge: 0; multiplicity: 1;
+        H     0.0000000000    0.0000000000    0.0000000000
+        F     0.0000000000    0.0000000000    1.0000000000
+        """
         lines = list(lines)
+        data: dict[str, Any] = {}
         if len(lines[0].split()) == 1:
-            natoms = lines[0].strip()
-            if not natoms.isdigit() or (int(lines[0]) != len(lines) - 2):
-                raise MoleculeReadError(f"First line of XYZ file should be the number of atoms, got: {lines[0]} != {len(lines) - 2}")
-            lines = lines[2:]
+            natoms, comment, *lines = lines
+            if (not natoms.strip().isdigit()) or (int(natoms) != len(lines)):
+                raise MoleculeReadError(f"First line of XYZ file should be the number of atoms ({len(lines)}), got: {natoms}")
+
+            data = cls._parse_comment_line(comment)
+
+        charge = charge if charge is not None else data.get("charge", 0)
+        multiplicity = multiplicity or data.get("multiplicity", 1)
+        data |= {"charge": charge, "multiplicity": multiplicity}
+
+        try:
+            return cls(atoms=[Atom.from_xyz(line) for line in lines], **data)
+        except (ValueError, ValidationError):
+            pass
 
         try:
             return cls(atoms=[Atom.from_xyz(line) for line in lines], charge=charge, multiplicity=multiplicity)
         except (ValueError, ValidationError) as e:
             raise MoleculeReadError("Error reading molecule from xyz") from e
 
-    def to_xyz(self, comment: str = "", out_file: Path | str | None = None) -> str:
+    @classmethod
+    def _parse_comment_line(cls, comment: str) -> dict[str, Any]:
+        """
+        Parse the comment line of an XYZ file.
+
+        :param comment: comment line from an XYZ file
+
+        >>> Molecule._parse_comment_line("charge: -1; multiplicity: 2; cell: [[1,2,3],[4,5,6],[7,8,9]]; is_periodic: (True, False, True); energy: -75.0")
+        {'charge': '-1', 'multiplicity': '2', 'energy': '-75.0', 'cell':\
+        PeriodicCell(lattice_vectors=((1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)), is_periodic=(True, False, True))}
+        >>> Molecule._parse_comment_line(" energy: -0.320207535977 gnorm: 0.071552110436 xtb: 6.6.1 (8d0f1dd)")  # Unfortunate
+        {'energy': '-0.320207535977 gnorm: 0.071552110436 xtb: 6.6.1 (8d0f1dd)'}
+        """
+        data: dict[str, Any] = {}
+        for kv in comment.split(";"):
+            try:
+                key, value = kv.split(":", 1)
+                data[key.strip()] = value.strip()
+            except ValueError:
+                logger.error(f"Error parsing key/value: {kv}")
+                continue
+
+        if cell := data.pop("cell", None):
+            try:
+                data["cell"] = PeriodicCell.from_string(cell)
+                if is_periodic := data.pop("is_periodic", None):
+                    x, y, z = is_periodic.strip(" ([)]").split(",")
+                    true_values = {"true", "1", "yes"}
+                    data["cell"].is_periodic = tuple(map(lambda v: v.strip().lower() in true_values, (x, y, z)))
+            except ValueError as e:
+                logger.error(f"Error parsing XYZ cell: {e}")
+                pass
+
+        return data
+
+    def to_xyz(self, comment: str | None = None, out_file: Path | str | None = None) -> str:
         r"""
         Generate an XYZ string.
 
-        >>> mol = Molecule.from_xyz("2\nComment\nH 0 1 2\nF 1 2 3")
-        >>> print(mol.to_xyz(comment="HF"))
+        :param comment: optional comment line (defaults to standard Rowan XYZ comment line format)
+        :param out_file: optional output file path to write the XYZ string to
+        :return: XYZ string
+
+        >>> mol = Molecule.from_xyz("2\nenergy: 1.0; smiles: HF;\nH 0 1 2\nF 1 2 3")
+        >>> print(mol.to_xyz())
         2
-        HF
+        charge: 0; multiplicity: 1; energy: 1.0; smiles: HF;
         H     0.0000000000    1.0000000000    2.0000000000
         F     1.0000000000    2.0000000000    3.0000000000
         >>> import tempfile
         >>> with tempfile.TemporaryDirectory() as directory:
         ...     file = Path(directory) / "mol.xyz"
-        ...     out = mol.to_xyz(comment="HF", out_file=file)
+        ...     out = mol.to_xyz(out_file=file)
         ...     with file.open() as f:
-        ...         Molecule.from_xyz(f.read()).to_xyz("HF") == out
+        ...         Molecule.from_xyz(f.read()).to_xyz() == out
         True
         """
         geom = "\n".join(map(str, self.atoms))
+        if comment is None:
+            data = self.model_dump(exclude_none=True, exclude={"atoms"})
+
+            if cell := data.pop("cell", None):
+                data["cell"] = cell["lattice_vectors"]
+                data["is_periodic"] = cell["is_periodic"]
+
+            comment = " ".join(f"{key}: {value};" for key, value in data.items())
+
         out = f"{len(self)}\n{comment}\n{geom}"
 
         if out_file:
@@ -442,7 +520,7 @@ def parse_extxyz_comment_line(line: str) -> EXTXYZMetadata:
     :return: parsed properties
 
     >>> parse_extxyz_comment_line('Lattice="6.0 0.0 0.0 6.0 0.0 0.0 6.0 0.0 0.0"Properties=species:S:1:pos:R:3')
-    {'cell': PeriodicCell(lattice_vectors=((6.0, 0.0, 0.0), (6.0, 0.0, 0.0), (6.0, 0.0, 0.0)), is_periodic=(True, True, True), volume=0.0), 'properties': 'species:S:1:pos:R:3'}
+    {'cell': PeriodicCell(lattice_vectors=((6.0, 0.0, 0.0), (6.0, 0.0, 0.0), (6.0, 0.0, 0.0)), is_periodic=(True, True, True)), 'properties': 'species:S:1:pos:R:3'}
     """  # noqa: E501
 
     # Regular expression to match key="value", key='value', or key=value

stjames-0.0.135/stjames/periodic_cell.py

@@ -0,0 +1,82 @@
+import ast
+from typing import Annotated, Self, TypeAlias
+
+import numpy as np
+import pydantic
+
+from .base import Base
+from .types import Matrix3x3, round_matrix3x3
+
+Bool3: TypeAlias = tuple[bool, bool, bool]
+
+
+class PeriodicCell(Base):
+    lattice_vectors: Annotated[Matrix3x3, pydantic.AfterValidator(round_matrix3x3(6))]
+    is_periodic: Bool3 = (True, True, True)
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the PeriodicCell.
+
+        >>> PeriodicCell(lattice_vectors=[[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+        PeriodicCell(lattice_vectors=((1.0, 2.0, 3.0), (4.0, 5.0, 6.0), (7.0, 8.0, 9.0)), is_periodic=(True, True, True))
+        """
+        return f"PeriodicCell(lattice_vectors={self.lattice_vectors}, is_periodic={self.is_periodic})"
+
+    @pydantic.field_validator("lattice_vectors")
+    @classmethod
+    def check_tensor_3D(cls, v: Matrix3x3) -> Matrix3x3:
+        if len(v) != 3 or any(len(row) != 3 for row in v):
+            raise ValueError("Cell tensor must be a 3x3 list of floats")
+
+        return v
+
+    @pydantic.field_validator("is_periodic")
+    @classmethod
+    def check_pbc(cls, v: Bool3) -> Bool3:
+        if not any(v):
+            raise ValueError("For periodic boundary conditions, at least one dimension must be periodic!")
+        return v
+
+    @pydantic.computed_field  # type: ignore[misc, prop-decorator, unused-ignore]
+    @property
+    def volume(self) -> float:
+        return float(np.abs(np.linalg.det(np.array(self.lattice_vectors))))
+
+    @classmethod
+    def from_string(cls, string: str) -> Self:
+        """
+        Create a PeriodicCell from a string representation.
+
+        >>> PeriodicCell.from_string("[(1, -2, 3.0), [4e1, +5, 6], (7.1, 8, 9)]")
+        PeriodicCell(lattice_vectors=((1.0, -2.0, 3.0), (40.0, 5.0, 6.0), (7.1, 8.0, 9.0)), is_periodic=(True, True, True))
+        >>> PeriodicCell.from_string("[(a, -2, 3.0), [4e1, +5, 6], (7.1, 8, 9)]")
+        Traceback (most recent call last):
+        ...
+        ValueError: Could not parse cell from string: [(a, -2, 3.0), [4e1, +5, 6], (7.1, 8, 9)]
+        >>> PeriodicCell.from_string("[(1, -2, 3.0), [4e1, +5, 6], (7.1, 8, 9, 10)]")
+        Traceback (most recent call last):
+        ...
+        ValueError: Cell must be a 3x3 matrix: got [(1, -2, 3.0), [4e1, +5, 6], (7.1, 8, 9, 10)]
+        >>> PeriodicCell.from_string("[('a', -2, 3.0), [4e1, +5, 6], (7.1, 8, 9)]")
+        Traceback (most recent call last):
+        ValueError: Cell must be a 3x3 matrix of numbers: got [('a', -2, 3.0), [4e1, +5, 6], (7.1, 8, 9)]
+
+        """
+        try:
+            cell = ast.literal_eval(string)
+        except (ValueError, SyntaxError) as e:
+            raise ValueError(f"Could not parse cell from string: {string}") from e
+
+        if not isinstance(cell, (list, tuple)):
+            raise ValueError(f"Cell must be a list or tuple: got {string}")
+        if not len(cell) == 3:
+            raise ValueError(f"Cell must be a 3x3 matrix: got {string}")
+        if not all(isinstance(row, (list, tuple)) for row in cell):
+            raise ValueError(f"Cell must be a 3x3 matrix: got {string}")
+        if not all(len(row) == 3 for row in cell):
+            raise ValueError(f"Cell must be a 3x3 matrix: got {string}")
+        if not all(all(isinstance(x, (int, float)) for x in row) for row in cell):
+            raise ValueError(f"Cell must be a 3x3 matrix of numbers: got {string}")
+
+        return cls(lattice_vectors=cell)

stjames-0.0.135/stjames/protein.py

@@ -0,0 +1,15 @@
+"""Protein-related data models."""
+
+from .base import Base
+
+
+class ProteinSequence(Base):
+    """
+    Protein sequence data.
+
+    :param sequence: amino-acid sequence string
+    :param cyclic: whether this sequence forms a cyclic peptide
+    """
+
+    sequence: str
+    cyclic: bool = False

stjames-0.0.135/stjames/rna.py

@@ -0,0 +1,13 @@
+"""RNA-related data models."""
+
+from .base import Base
+
+
+class RNASequence(Base):
+    """
+    RNA sequence data.
+
+    :param sequence: nucleotide string
+    """
+
+    sequence: str

{stjames-0.0.114 → stjames-0.0.135}/stjames/settings.py

@@ -6,6 +6,7 @@ from .base import Base, UniqueList
 from .basis_set import BasisSet
 from .compute_settings import ComputeSettings
 from .correction import Correction
+from .engine import Engine
 from .method import CORRECTABLE_NNP_METHODS, METHODS_WITH_CORRECTION, PREPACKAGED_METHODS, Method
 from .mode import Mode
 from .opt_settings import OptimizationSettings
@@ -20,11 +21,13 @@ _T = TypeVar("_T")
 class Settings(Base):
     mode: Mode = Mode.AUTO
 
+    # DEPRECATED - specify tasks only in BasicCalculationWorkflow or Calculation now
+    tasks: UniqueList[Task] = [Task.ENERGY, Task.CHARGE, Task.DIPOLE]
+
     method: Method = Method.HARTREE_FOCK
     basis_set: Optional[BasisSet] = None
-    tasks: UniqueList[Task] = [Task.ENERGY, Task.CHARGE, Task.DIPOLE]
+    engine: Engine = None  # type: ignore [assignment]
     corrections: UniqueList[Correction] = []
-
     solvent_settings: Optional[SolventSettings] = None
 
     # scf/opt settings will be set automatically based on mode, but can be overridden manually
@@ -33,6 +36,12 @@ class Settings(Base):
     thermochem_settings: ThermochemistrySettings = ThermochemistrySettings()
     compute_settings: ComputeSettings = ComputeSettings()
 
+    @model_validator(mode="after")
+    def set_engine(self) -> Self:
+        """Set the calculation engine."""
+        self.engine = self.engine or self.method.default_engine()
+        return self
+
     # mypy has this dead wrong (https://docs.pydantic.dev/2.0/usage/computed_fields/)
     # Python 3.12 narrows the reason for the ignore to prop-decorator
     @computed_field  # type: ignore[misc, prop-decorator, unused-ignore]

{stjames-0.0.114 → stjames-0.0.135}/stjames/solvent.py

@@ -26,6 +26,7 @@ class Solvent(LowercaseStrEnum):
     METHANOL = "methanol"
     ETHANOL = "ethanol"
     ISOPROPANOL = "isopropanol"
+    OCTANOL = "octanol"
     DIMETHYLACETAMIDE = "dimethylacetamide"
     DIMETHYLFORMAMIDE = "dimethylformamide"
     N_METHYLPYRROLIDONE = "n_methylpyrrolidone"
@@ -39,6 +40,7 @@ class SolventModel(LowercaseStrEnum):
     COSMO = "cosmo"
     GBSA = "gbsa"
     CPCMX = "cpcmx"
+    SMD = "SMD"
 
 
 class SolventSettings(Base):

{stjames-0.0.114 → stjames-0.0.135}/stjames/workflows/__init__.py

@@ -4,6 +4,7 @@ from typing import Literal
 
 from .admet import *
 from .basic_calculation import *
+from .batch_docking import *
 from .bde import *
 from .conformer import *
 from .conformer_search import *
@@ -17,12 +18,18 @@ from .ion_mobility import *
 from .irc import *
 from .macropka import *
 from .molecular_dynamics import *
+from .msa import *
 from .multistage_opt import *
 from .nmr import *
 from .pka import *
 from .pose_analysis_md import *
+from .protein_binder_design import *
 from .protein_cofolding import *
 from .redox_potential import *
+from .relative_binding_free_energy_perturbation import (
+    RBFEGraphWorkflow,
+    RelativeBindingFreeEnergyPerturbationWorkflow,
+)
 from .scan import *
 from .solubility import *
 from .spin_states import *
@@ -33,6 +40,7 @@ from .workflow import *
 WORKFLOW_NAME = Literal[
     "admet",
     "basic_calculation",
+    "batch_docking",
     "bde",
     "conformers",
     "conformer_search",
@@ -40,17 +48,21 @@ WORKFLOW_NAME = Literal[
     "docking",
     "double_ended_ts_search",
     "electronic_properties",
+    "relative_binding_free_energy_perturbation",
     "fukui",
     "hydrogen_bond_basicity",
     "ion_mobility",
     "irc",
     "macropka",
     "molecular_dynamics",
+    "msa",
     "multistage_opt",
     "nmr",
     "pka",
     "pose_analysis_md",
     "protein_cofolding",
+    "protein_binder_design",
+    "rbfe_graph",
     "redox_potential",
     "scan",
     "solubility",
@@ -62,6 +74,7 @@ WORKFLOW_NAME = Literal[
 WORKFLOW_MAPPING: dict[WORKFLOW_NAME, Workflow] = {
     "admet": ADMETWorkflow,  # type: ignore [dict-item]
     "basic_calculation": BasicCalculationWorkflow,  # type: ignore [dict-item]
+    "batch_docking": BatchDockingWorkflow,  # type: ignore [dict-item]
     "bde": BDEWorkflow,  # type: ignore [dict-item]
     "conformers": ConformerWorkflow,  # type: ignore [dict-item]
     "conformer_search": ConformerSearchWorkflow,  # type: ignore [dict-item]
@@ -69,6 +82,7 @@ WORKFLOW_MAPPING: dict[WORKFLOW_NAME, Workflow] = {
     "docking": DockingWorkflow,  # type: ignore [dict-item]
     "double_ended_ts_search": DoubleEndedTSSearchWorkflow,  # type: ignore [dict-item]
     "electronic_properties": ElectronicPropertiesWorkflow,  # type: ignore [dict-item]
+    "relative_binding_free_energy_perturbation": RelativeBindingFreeEnergyPerturbationWorkflow,  # type: ignore [dict-item]
     "fukui": FukuiIndexWorkflow,  # type: ignore [dict-item]
     "hydrogen_bond_basicity": HydrogenBondBasicityWorkflow,  # type: ignore [dict-item]
     "ion_mobility": IonMobilityWorkflow,  # type: ignore [dict-item]
@@ -76,10 +90,13 @@ WORKFLOW_MAPPING: dict[WORKFLOW_NAME, Workflow] = {
     "macropka": MacropKaWorkflow,  # type: ignore [dict-item]
     "molecular_dynamics": MolecularDynamicsWorkflow,  # type: ignore [dict-item]
     "multistage_opt": MultiStageOptWorkflow,  # type: ignore [dict-item]
+    "msa": MSAWorkflow,  # type: ignore [dict-item]
     "nmr": NMRSpectroscopyWorkflow,  # type: ignore [dict-item]
     "pka": pKaWorkflow,  # type: ignore [dict-item]
     "pose_analysis_md": PoseAnalysisMolecularDynamicsWorkflow,  # type: ignore [dict-item]
     "protein_cofolding": ProteinCofoldingWorkflow,  # type: ignore [dict-item]
+    "protein_binder_design": ProteinBinderDesignWorkflow,  # type: ignore [dict-item]
+    "rbfe_graph": RBFEGraphWorkflow,  # type: ignore [dict-item]
     "redox_potential": RedoxPotentialWorkflow,  # type: ignore [dict-item]
     "scan": ScanWorkflow,  # type: ignore [dict-item]
     "solubility": SolubilityWorkflow,  # type: ignore [dict-item]

{stjames-0.0.114 → stjames-0.0.135}/stjames/workflows/basic_calculation.py

@@ -4,8 +4,10 @@ from typing import Self
 
 from pydantic import model_validator
 
+from ..base import UniqueList
 from ..engine import Engine
 from ..settings import Settings
+from ..task import Task
 from ..types import UUID
 from .workflow import MoleculeWorkflow
 
@@ -25,12 +27,15 @@ class BasicCalculationWorkflow(MoleculeWorkflow):
     """
 
     settings: Settings
-    engine: Engine = None  # type: ignore [assignment]
+    tasks: UniqueList[Task] = [Task.ENERGY, Task.CHARGE, Task.DIPOLE]
     calculation_uuid: UUID | None = None
 
+    # DEPRECATED - specify in settings now
+    engine: Engine = None  # type: ignore [assignment]
+
     @model_validator(mode="after")
     def set_engine(self) -> Self:
         """Set the calculation engine."""
-        self.engine = self.engine or self.settings.method.default_engine()
+        self.engine = self.engine or self.settings.engine
 
         return self