stjames 0.0.49__tar.gz → 0.0.50__tar.gz

{stjames-0.0.49/stjames.egg-info → stjames-0.0.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: stjames
-Version: 0.0.49
+Version: 0.0.50
 Summary: standardized JSON atom/molecule encoding scheme
 Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/stjames
@@ -11,6 +11,7 @@ License-File: LICENSE
 Requires-Dist: atomium<2,>=1
 Requires-Dist: pydantic>=2.4
 Requires-Dist: numpy
+Requires-Dist: atomium<2.0,>=1.0
 
 # stjames
 

{stjames-0.0.49 → stjames-0.0.50}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stjames"
-version = "0.0.49"
+version = "0.0.50"
 description = "standardized JSON atom/molecule encoding scheme"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -12,6 +12,7 @@ dependencies = [
     "atomium>=1,<2",
     "pydantic>=2.4",
     "numpy",
+    "atomium>=1.0,<2.0",
 ]
 
 [build-system]

{stjames-0.0.49 → stjames-0.0.50}/stjames/atom.py

@@ -1,15 +1,15 @@
-from typing import Self, Sequence
+from typing import Annotated, Self, Sequence
 
-from pydantic import NonNegativeInt
+from pydantic import AfterValidator, NonNegativeInt
 
 from .base import Base
 from .data import ELEMENT_SYMBOL, SYMBOL_ELEMENT
-from .types import Vector3D
+from .types import Vector3D, round_vector3d
 
 
 class Atom(Base):
     atomic_number: NonNegativeInt
-    position: Vector3D  # in Å
+    position: Annotated[Vector3D, AfterValidator(round_vector3d(8))]  # in Å
 
     def __repr__(self) -> str:
         """

{stjames-0.0.49 → stjames-0.0.50}/stjames/base.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Annotated, Any, Hashable, TypeVar
+from typing import Annotated, Any, Callable, Hashable, Optional, TypeVar
 
 import numpy as np
 import pydantic
@@ -7,6 +7,26 @@ import pydantic
 _T = TypeVar("_T")
 
 
+def round_float(round_to: int) -> Callable[[float], float]:
+    """Return a function that rounds a float to a given number of decimal places."""
+
+    def inner_round(v: float) -> float:
+        return round(v, round_to)
+
+    return inner_round
+
+
+def round_optional_float(round_to: int) -> Callable[[Optional[float]], Optional[float]]:
+    """Create a validator that rounds an optional float to a given number of decimal places."""
+
+    def rounder(value: Optional[float]) -> Optional[float]:
+        if value is None:
+            return None
+        return round(value, round_to)
+
+    return rounder
+
+
 class Base(pydantic.BaseModel):
     @pydantic.field_validator("*", mode="before")
     @classmethod

{stjames-0.0.49 → stjames-0.0.50}/stjames/compute_settings.py

@@ -4,7 +4,9 @@ from .base import Base, LowercaseStrEnum
 class ComputeType(LowercaseStrEnum):
     CPU = "cpu"
     GPU = "gpu"
+    AUTO = "auto"
 
 
 class ComputeSettings(Base):
-    compute_type: ComputeType = ComputeType.CPU
+    requested_compute_type: ComputeType = ComputeType.CPU
+    compute_type_used: ComputeType | None = None

{stjames-0.0.49 → stjames-0.0.50}/stjames/method.py

@@ -47,9 +47,11 @@ class Method(LowercaseStrEnum):
 
     OFF_SAGE_2_2_1 = "off_sage_2_2_1"
 
+    RM1 = "rm1"
 
-PrepackagedNNPMethod = Literal[Method.AIMNET2_WB97MD3, Method.OCP24_S, Method.OCP24_L]
-PREPACKAGED_NNP_METHODS = [Method.AIMNET2_WB97MD3, Method.OCP24_S, Method.OCP24_L]
+
+PrepackagedNNPMethod = Literal[Method.AIMNET2_WB97MD3, Method.OCP24_S, Method.OCP24_L, Method.RM1]
+PREPACKAGED_NNP_METHODS = [Method.AIMNET2_WB97MD3, Method.OCP24_S, Method.OCP24_L, Method.RM1]
 
 CorrectableNNPMethod = Literal[Method.MACE_MP_0B2_L, Method.ORB_V2]
 CORRECTABLE_NNP_METHODS = [Method.MACE_MP_0B2_L, Method.ORB_V2]

{stjames-0.0.49 → stjames-0.0.50}/stjames/molecule.py

@@ -1,14 +1,24 @@
 import re
 from pathlib import Path
-from typing import Iterable, Optional, Self
+from typing import Annotated, Iterable, Optional, Self
 
 import pydantic
-from pydantic import NonNegativeInt, PositiveInt, ValidationError
+from pydantic import AfterValidator, NonNegativeInt, PositiveInt, ValidationError
 
 from .atom import Atom
-from .base import Base
+from .base import Base, round_float, round_optional_float
 from .periodic_cell import PeriodicCell
-from .types import FloatPerAtom, Matrix3x3, Vector3D, Vector3DPerAtom
+from .types import (
+    FloatPerAtom,
+    Matrix3x3,
+    Vector3D,
+    Vector3DPerAtom,
+    round_optional_float_per_atom,
+    round_optional_matrix3x3,
+    round_optional_vector3d,
+    round_optional_vector3d_per_atom,
+    round_vector3d_per_atom,
+)
 
 
 class MoleculeReadError(RuntimeError):
@@ -16,10 +26,10 @@ class MoleculeReadError(RuntimeError):
 
 
 class VibrationalMode(Base):
-    frequency: float  # in cm-1
-    reduced_mass: float  # amu
-    force_constant: float  # mDyne/Å
-    displacements: Vector3DPerAtom  # Å
+    frequency: Annotated[float, AfterValidator(round_float(3))]  # in cm-1
+    reduced_mass: Annotated[float, AfterValidator(round_float(3))]  # amu
+    force_constant: Annotated[float, AfterValidator(round_float(3))]  # mDyne/Å
+    displacements: Annotated[Vector3DPerAtom, AfterValidator(round_vector3d_per_atom(6))]  # Å
 
 
 class Molecule(Base):
@@ -30,28 +40,28 @@ class Molecule(Base):
     # for periodic boundary conditions
     cell: Optional[PeriodicCell] = None
 
-    energy: Optional[float] = None  # in Hartree
+    energy: Annotated[Optional[float], AfterValidator(round_optional_float(6))] = None  # in Hartree
     scf_iterations: Optional[NonNegativeInt] = None
     scf_completed: Optional[bool] = None
-    elapsed: Optional[float] = None  # in seconds
+    elapsed: Annotated[Optional[float], AfterValidator(round_optional_float(3))] = None  # in seconds
 
-    homo_lumo_gap: Optional[float] = None  # in eV
+    homo_lumo_gap: Annotated[Optional[float], AfterValidator(round_optional_float(6))] = None  # in eV
 
-    gradient: Optional[Vector3DPerAtom] = None  # Hartree/Å
-    stress: Optional[Matrix3x3] = None  # Hartree/Å
+    gradient: Annotated[Optional[Vector3DPerAtom], AfterValidator(round_optional_vector3d_per_atom(6))] = None  # Hartree/Å
+    stress: Annotated[Optional[Matrix3x3], AfterValidator(round_optional_matrix3x3(6))] = None  # Hartree/Å
 
-    velocities: Optional[Vector3DPerAtom] = None  # Å/fs
+    velocities: Annotated[Optional[Vector3DPerAtom], AfterValidator(round_optional_vector3d_per_atom(6))] = None  # Å/fs
 
-    mulliken_charges: FloatPerAtom | None = None
-    mulliken_spin_densities: FloatPerAtom | None = None
-    dipole: Optional[Vector3D] = None  # in Debye
+    mulliken_charges: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None
+    mulliken_spin_densities: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None
+    dipole: Annotated[Optional[Vector3D], AfterValidator(round_optional_vector3d(6))] = None  # in Debye
 
     vibrational_modes: Optional[list[VibrationalMode]] = None
 
-    zero_point_energy: Optional[float] = None
-    thermal_energy_corr: Optional[float] = None
-    thermal_enthalpy_corr: Optional[float] = None
-    thermal_free_energy_corr: Optional[float] = None
+    zero_point_energy: Annotated[Optional[float], AfterValidator(round_optional_float(6))] = None
+    thermal_energy_corr: Annotated[Optional[float], AfterValidator(round_optional_float(6))] = None
+    thermal_enthalpy_corr: Annotated[Optional[float], AfterValidator(round_optional_float(6))] = None
+    thermal_free_energy_corr: Annotated[Optional[float], AfterValidator(round_optional_float(6))] = None
 
     smiles: Optional[str] = None
 
@@ -72,6 +82,25 @@ class Molecule(Base):
     def coordinates(self) -> Vector3DPerAtom:
         return [a.position for a in self.atoms]
 
+    def translated(self, vector: Vector3D) -> Self:
+        r"""
+        Translate the molecule by a vector.
+
+        >>> mol = Molecule.from_xyz("H 0 0 0\nH 0 0 1")
+        >>> print(mol.translated((1, 0, 0)).to_xyz())
+        2
+        <BLANKLINE>
+        H     1.0000000000    0.0000000000    0.0000000000
+        H     1.0000000000    0.0000000000    1.0000000000
+        """
+
+        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]
+
+        return self.copy(update={"atoms": atoms})
+
     @property
     def atomic_numbers(self) -> list[NonNegativeInt]:
         return [a.atomic_number for a in self.atoms]

{stjames-0.0.49 → stjames-0.0.50}/stjames/periodic_cell.py

@@ -1,16 +1,16 @@
-from typing import TypeAlias
+from typing import Annotated, TypeAlias
 
 import numpy as np
 import pydantic
 
 from .base import Base
-from .types import Matrix3x3
+from .types import Matrix3x3, round_matrix3x3
 
 Bool3: TypeAlias = tuple[bool, bool, bool]
 
 
 class PeriodicCell(Base):
-    lattice_vectors: Matrix3x3
+    lattice_vectors: Annotated[Matrix3x3, pydantic.AfterValidator(round_matrix3x3(6))]
     is_periodic: Bool3 = (True, True, True)
 
     @pydantic.field_validator("lattice_vectors")

stjames-0.0.50/stjames/types.py

@@ -0,0 +1,98 @@
+from typing import Callable, TypeAlias
+
+UUID: TypeAlias = str
+
+Vector3D: TypeAlias = tuple[float, float, float]
+Vector3DPerAtom: TypeAlias = list[Vector3D]
+
+FloatPerAtom: TypeAlias = list[float]
+
+Matrix3x3: TypeAlias = tuple[Vector3D, Vector3D, Vector3D]
+
+
+def round_vector3d(round_to: int = 6) -> Callable[[Vector3D], Vector3D]:
+    """Create a validator that rounds each component of a Vector3D to a given number of decimal places."""
+
+    def rounder(vector: Vector3D) -> Vector3D:
+        return (round(vector[0], round_to), round(vector[1], round_to), round(vector[2], round_to))
+
+    return rounder
+
+
+def round_optional_vector3d(round_to: int = 6) -> Callable[[Vector3D | None], Vector3D | None]:
+    """Create a validator that rounds each component of a Vector3D to a given number of decimal places, handling None."""
+
+    def rounder(vector: Vector3D | None) -> Vector3D | None:
+        if vector is None:
+            return None
+        return (round(vector[0], round_to), round(vector[1], round_to), round(vector[2], round_to))
+
+    return rounder
+
+
+def round_vector3d_per_atom(round_to: int = 6) -> Callable[[Vector3DPerAtom], Vector3DPerAtom]:
+    """Create a validator that rounds each vector in Vector3DPerAtom to a given number of decimal places."""
+    vector_rounder = round_vector3d(round_to)
+
+    def rounder(vectors: Vector3DPerAtom) -> Vector3DPerAtom:
+        return [vector_rounder(v) for v in vectors]
+
+    return rounder
+
+
+def round_optional_vector3d_per_atom(round_to: int = 6) -> Callable[[Vector3DPerAtom | None], Vector3DPerAtom | None]:
+    """Create a validator that rounds each vector in Vector3DPerAtom to a given number of decimal places, handling None."""
+    vector_rounder = round_vector3d(round_to)
+
+    def rounder(vectors: Vector3DPerAtom | None) -> Vector3DPerAtom | None:
+        if vectors is None:
+            return None
+        return [vector_rounder(v) for v in vectors]
+
+    return rounder
+
+
+def round_matrix3x3(round_to: int = 6) -> Callable[[Matrix3x3], Matrix3x3]:
+    """Create a validator that rounds each vector in a Matrix3x3 to a given number of decimal places."""
+
+    # Use the round_vector3d function to round each Vector3D in the Matrix3x3
+    vector_rounder = round_vector3d(round_to)
+
+    def rounder(matrix: Matrix3x3) -> Matrix3x3:
+        return (vector_rounder(matrix[0]), vector_rounder(matrix[1]), vector_rounder(matrix[2]))
+
+    return rounder
+
+
+def round_optional_matrix3x3(round_to: int = 3) -> Callable[[Matrix3x3 | None], Matrix3x3 | None]:
+    """Create a validator that rounds each vector in an Optional Matrix3x3 to a given number of decimal places."""
+
+    # Use the round_vector3d function to round each Vector3D in the Matrix3x3
+    vector_rounder = round_vector3d(round_to)
+
+    def rounder(matrix: Matrix3x3 | None) -> Matrix3x3 | None:
+        if matrix is None:
+            return None
+        return (vector_rounder(matrix[0]), vector_rounder(matrix[1]), vector_rounder(matrix[2]))
+
+    return rounder
+
+
+def round_optional_float_per_atom(round_to: int = 6) -> Callable[[FloatPerAtom | None], FloatPerAtom | None]:
+    """Create a validator that rounds each float in FloatPerAtom to a given number of decimal places, handling None."""
+
+    def rounder(values: FloatPerAtom | None) -> FloatPerAtom | None:
+        if values is None:
+            return None
+        return [round(value, round_to) for value in values]
+
+    return rounder
+
+
+def round_float_per_atom(round_to: int = 6) -> Callable[[FloatPerAtom], FloatPerAtom]:
+    """Create a validator that rounds each float in FloatPerAtom to a given number of decimal places, handling None."""
+
+    def rounder(values: FloatPerAtom) -> FloatPerAtom:
+        return [round(value, round_to) for value in values]
+
+    return rounder

{stjames-0.0.49 → stjames-0.0.50}/stjames/workflows/__init__.py

@@ -1,4 +1,5 @@
 # ruff: noqa: F405
+
 from typing import Literal
 
 from .admet import *
@@ -7,9 +8,11 @@ from .bde import *
 from .conformer import *
 from .conformer_search import *
 from .descriptors import *
+from .docking import *
 from .electronic_properties import *
 from .fukui import *
 from .hydrogen_bond_basicity import *
+from .irc import *
 from .molecular_dynamics import *
 from .multistage_opt import *
 from .pka import *
@@ -26,9 +29,11 @@ WORKFLOW_NAME = Literal[
     "conformers",
     "conformer_search",
     "descriptors",
+    "docking",
     "electronic_properties",
     "fukui",
     "hydrogen_bond_basicity",
+    "irc",
     "molecular_dynamics",
     "multistage_opt",
     "pka",
@@ -45,9 +50,11 @@ WORKFLOW_MAPPING: dict[str, Workflow] = {
     "conformers": ConformerWorkflow,  # type: ignore [dict-item]
     "conformer_search": ConformerSearchWorkflow,  # type: ignore [dict-item]
     "descriptors": DescriptorsWorkflow,  # type: ignore [dict-item]
+    "docking": DockingWorkflow,  # type: ignore [dict-item]
     "electronic_properties": ElectronicPropertiesWorkflow,  # type: ignore [dict-item]
     "fukui": FukuiIndexWorkflow,  # type: ignore [dict-item]
     "hydrogen_bond_basicity": HydrogenBondBasicityWorkflow,  # type: ignore [dict-item]
+    "irc": IRCWorkflow,  # type: ignore [dict-item]
     "molecular_dynamics": MolecularDynamicsWorkflow,  # type: ignore [dict-item]
     "multistage_opt": MultiStageOptWorkflow,  # type: ignore [dict-item]
     "pka": pKaWorkflow,  # type: ignore [dict-item]

{stjames-0.0.49 → stjames-0.0.50}/stjames/workflows/bde.py

@@ -1,10 +1,11 @@
 """Bond Dissociation Energy (BDE) workflow."""
 
 import itertools
-from typing import Any, Iterable, Self, TypeVar
+from typing import Annotated, Any, Iterable, Self, TypeVar
 
-from pydantic import BaseModel, Field, PositiveInt, ValidationInfo, field_validator, model_validator
+from pydantic import AfterValidator, BaseModel, Field, PositiveInt, ValidationInfo, field_validator, model_validator
 
+from ..base import round_optional_float
 from ..mode import Mode
 from ..molecule import Molecule
 from ..types import UUID
@@ -29,7 +30,7 @@ class BDE(BaseModel):
     """
 
     fragment_idxs: tuple[PositiveInt, ...]
-    energy: float | None
+    energy: Annotated[float | None, AfterValidator(round_optional_float(6))]
     fragment_energies: tuple[float | None, float | None]
     calculation_uuids: tuple[list[UUID | None], list[UUID | None]]
 

{stjames-0.0.49 → stjames-0.0.50}/stjames/workflows/conformer.py

@@ -1,6 +1,8 @@
-from typing import Any, Optional
+from typing import Annotated, Any, Optional
 
-from ..base import Base
+from pydantic import AfterValidator
+
+from ..base import Base, round_float, round_optional_float
 from ..constraint import Constraint
 from ..method import Method
 from ..mode import Mode
@@ -33,8 +35,8 @@ class CrestConformerSettings(ConformerSettings):
 
 
 class Conformer(Base):
-    energy: float
-    weight: Optional[float] = None
+    energy: Annotated[float, AfterValidator(round_float(6))]
+    weight: Annotated[float | None, AfterValidator(round_optional_float(6))] = None
 
     # uuid, optionally
     uuid: Optional[str] = None

{stjames-0.0.49 → stjames-0.0.50}/stjames/workflows/conformer_search.py

@@ -1,16 +1,15 @@
 """Conformer Search Workflow."""
 
 from abc import ABC
-from typing import Self, Sequence, TypeVar
+from typing import Annotated, Self, Sequence, TypeVar
 
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import AfterValidator, BaseModel, Field, field_validator, model_validator
 
 from ..base import LowercaseStrEnum
 from ..constraint import Constraint
 from ..method import Method, XTBMethod
 from ..mode import Mode
-from ..task import Task
-from ..types import UUID
+from ..types import UUID, FloatPerAtom, round_float_per_atom
 from .multistage_opt import MultiStageOptMixin
 from .workflow import Workflow
 
@@ -323,30 +322,6 @@ class ConformerSearchMixin(ConformerGenMixin, MultiStageOptMixin):
         """Return a string representation of the ConformerSearch workflow."""
         return f"<{type(self).__name__} {self.conf_gen_mode.name} {self.mso_mode.name}>"
 
-    @model_validator(mode="after")
-    def deduplicate(self) -> Self:
-        """
-        Deduplicate optimizations between conf_gen and multistage_opt.
-
-        Also affects Manual Mode.
-        """
-        cgs = self.conf_gen_settings
-        msos = self.multistage_opt_settings
-
-        if self.transition_state or not msos.optimization_settings:
-            return self
-
-        first_opt = msos.optimization_settings[0]
-        if cgs.conf_opt_method != first_opt.method or "optimize" not in first_opt.tasks:
-            return self
-
-        first_opt.tasks.remove(Task.OPTIMIZE)
-        if msos.singlepoint_settings or len(msos.optimization_settings) > 1:
-            if (not first_opt.tasks) or first_opt.tasks == ["singlepoint"]:
-                msos.optimization_settings = msos.optimization_settings[1:]
-
-        return self
-
     @model_validator(mode="after")
     def remove_ts_constraints(self) -> Self:
         """
@@ -389,4 +364,4 @@ class ConformerSearchWorkflow(ConformerSearchMixin, Workflow):
 
     # Results
     conformer_uuids: list[list[UUID | None]] = Field(default_factory=list)
-    energies: list[float] = Field(default_factory=list)
+    energies: Annotated[FloatPerAtom, AfterValidator(round_float_per_atom(6))] = Field(default_factory=list)

stjames-0.0.50/stjames/workflows/docking.py

@@ -0,0 +1,80 @@
+"""Docking workflow."""
+
+from typing import Self
+
+from pydantic import BaseModel, ConfigDict, field_validator, model_validator
+
+from ..molecule import Molecule
+from ..pdb import PDB
+from ..types import Vector3D
+from .workflow import Workflow
+
+
+class Score(BaseModel):
+    """
+    Pose with its score.
+
+    :param pose: conformation of the ligand when docked
+    :param score: score of the pose
+    """
+
+    pose: Molecule
+    score: float
+
+
+class DockingWorkflow(Workflow):
+    """
+    Docking workflow.
+
+    Inherited:
+    :param initial_molecule: Molecule of interest (currently unused)
+    :param mode: Mode for workflow (currently unused)
+
+    New:
+    :param molecules: Molecules to dock (optional)
+    :param smiles: SMILES strings of the ligands (optional)
+    :param target: PDB of the protein
+    :param pocket: center (x, y, z) and size (x, y, z) of the pocket
+
+    Results:
+    :param scores: docked poses sorted by score
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    molecules: list[Molecule] = []
+    smiles: list[str] = []
+
+    target: PDB
+    pocket: tuple[Vector3D, Vector3D]
+
+    scores: list[Score] = []
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the Docking workflow."""
+        desc = self.target.description
+        target = desc.code or desc.title
+        ligand = "".join(atom.atomic_symbol for atom in self.initial_molecule.atoms)
+
+        return f"<{type(self).__name__} {target} {ligand}>"
+
+    @model_validator(mode="after")
+    def check_molecules(self) -> Self:
+        """Check if molecules are provided."""
+        if self.molecules and self.smiles:
+            raise ValueError("Must provide only one of molecules or smiles, not both")
+        elif not self.molecules and not self.smiles:
+            raise ValueError("Must provide either molecules or smiles")
+
+        return self
+
+    @field_validator("pocket", mode="after")
+    def validate_pocket(cls, pocket: tuple[Vector3D, Vector3D]) -> tuple[Vector3D, Vector3D]:
+        center, size = pocket
+        if any(q <= 0 for q in size):
+            raise ValueError(f"Pocket size must be positive, got: {size}")
+
+        return pocket

{stjames-0.0.49 → stjames-0.0.50}/stjames/workflows/electronic_properties.py

@@ -1,22 +1,13 @@
-from typing import Annotated, Callable
+from typing import Annotated
 
 from pydantic import AfterValidator, NonNegativeFloat, NonNegativeInt
 
-from ..base import Base
+from ..base import Base, round_float
 from ..settings import Settings
-from ..types import UUID, FloatPerAtom, Matrix3x3, Vector3D
+from ..types import UUID, FloatPerAtom, Matrix3x3, Vector3D, round_optional_float_per_atom, round_optional_matrix3x3, round_optional_vector3d
 from .workflow import Workflow
 
 
-def round_float(round_to: int) -> Callable[[float], float]:
-    """Return a function that rounds a float to a given number of decimal places."""
-
-    def inner_round(v: float) -> float:
-        return round(v, round_to)
-
-    return inner_round
-
-
 class PropertyCubePoint(Base):
     """A point in a cube file, all values rounded to 6 decimal places."""
 
@@ -40,7 +31,7 @@ class MolecularOrbitalCube(PropertyCube):
     """
 
     occupation: NonNegativeInt
-    energy: float
+    energy: Annotated[float, AfterValidator(round_float(6))]
 
 
 class ElectronicPropertiesWorkflow(Workflow):
@@ -88,11 +79,11 @@ class ElectronicPropertiesWorkflow(Workflow):
     # Results
     calc_uuid: UUID | None = None
 
-    dipole: Vector3D | None = None
-    quadrupole: Matrix3x3 | None = None
+    dipole: Annotated[Vector3D | None, AfterValidator(round_optional_vector3d(6))] = None
+    quadrupole: Annotated[Matrix3x3 | None, AfterValidator(round_optional_matrix3x3(6))] = None
 
-    mulliken_charges: FloatPerAtom | None = None
-    lowdin_charges: FloatPerAtom | None = None
+    mulliken_charges: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None
+    lowdin_charges: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None
 
     wiberg_bond_orders: list[tuple[NonNegativeInt, NonNegativeInt, NonNegativeFloat]] = []
     mayer_bond_orders: list[tuple[NonNegativeInt, NonNegativeInt, NonNegativeFloat]] = []

stjames-0.0.50/stjames/workflows/fukui.py

@@ -0,0 +1,17 @@
+from typing import Annotated
+
+from pydantic import AfterValidator
+
+from ..base import round_optional_float
+from ..types import UUID, FloatPerAtom, round_optional_float_per_atom
+from .workflow import Workflow
+
+
+class FukuiIndexWorkflow(Workflow):
+    # UUID of optimization
+    optimization: UUID | None = None
+
+    global_electrophilicity_index: Annotated[float | None, AfterValidator(round_optional_float(6))] = None
+    fukui_positive: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None
+    fukui_negative: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None
+    fukui_zero: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None

stjames-0.0.50/stjames/workflows/irc.py

@@ -0,0 +1,90 @@
+from typing import Self
+
+from pydantic import Field, model_validator
+
+from ..method import XTB_METHODS, Method
+from ..mode import Mode
+from ..settings import Settings
+from ..solvent import Solvent, SolventModel, SolventSettings
+from ..types import UUID
+from .workflow import Workflow
+
+_sentinel_settings: Settings = object()  # type: ignore [assignment]
+
+
+class IRCWorkflow(Workflow):
+    """
+    Workflow for Intrinsic Reaction Coordinate (IRC) calculations.
+
+    Inherited:
+    :param initial_molecule: Molecule of interest
+    :param mode: Mode for workflow
+
+    New:
+    :param settings: Settings for running the IRC (only for manual mode)
+    :param solvent: Solvent for the calculation (non-Manual mode only)
+    :param preopt: whether to optimize the geometry before starting the IRC
+    :param final_opt: whether to optimize the final IRC geometry to a minimum
+
+    Results:
+    :param starting_TS: optimized TS before the IRC (==initial_molecule if preopt=False)
+    :param irc_forward: forward calculations
+    :param irc_backward: reverse calculations
+    :param opt_forward: optimization steps after the forward IRC
+    :param opt_backward: optimization steps after the reverse IRC
+    """
+
+    settings: Settings = _sentinel_settings
+    solvent: Solvent | None = None
+
+    preopt: bool = False
+    final_opt: bool = False
+
+    starting_TS: UUID | None = None
+
+    irc_forward: list[UUID] = Field(default_factory=list)
+    irc_backward: list[UUID] = Field(default_factory=list)
+    opt_forward: list[UUID] = Field(default_factory=list)
+    opt_backward: list[UUID] = Field(default_factory=list)
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        """String representation of the workflow."""
+        if self.mode != Mode.MANUAL:
+            return f"<{type(self).__name__} {self.mode.name}>"
+
+        return f"<{type(self).__name__} {self.level_of_theory}>"
+
+    @property
+    def level_of_theory(self) -> str:
+        """Level of theory for the workflow."""
+        return self.settings.level_of_theory
+
+    @model_validator(mode="after")
+    def validate_mode(self) -> Self:
+        """Convert the mode to settings."""
+        if self.mode == Mode.MANUAL:
+            if self.settings is _sentinel_settings:
+                raise ValueError("Settings are required for manual calculations.")
+            return self
+        elif self.settings is not _sentinel_settings:
+            raise ValueError("Cannot specify settings and mode simultaneously.")
+
+        match self.mode:
+            case Mode.RAPID:
+                method = Method.GFN2_XTB
+            case Mode.CAREFUL:
+                method = Method.R2SCAN3C
+            case Mode.METICULOUS:
+                method = Method.WB97X3C
+            case _:
+                raise ValueError(f"Unsupported mode: {self.mode}")
+
+        model = SolventModel.ALPB if method in XTB_METHODS else SolventModel.CPCM
+        solvent_settings = SolventSettings(solvent=self.solvent, model=model) if self.solvent else None
+
+        self.settings = Settings(mode=Mode.RAPID, method=method, solvent_settings=solvent_settings)
+
+        return self

{stjames-0.0.49 → stjames-0.0.50}/stjames/workflows/pka.py

@@ -1,6 +1,8 @@
-from typing import Optional
+from typing import Annotated
 
-from ..base import Base
+from pydantic import AfterValidator
+
+from ..base import Base, round_float, round_optional_float
 from ..mode import Mode
 from .workflow import DBCalculation, Workflow
 
@@ -8,8 +10,8 @@ from .workflow import DBCalculation, Workflow
 class pKaMicrostate(Base):
     atom_index: int
     structures: list[DBCalculation] = []
-    deltaG: float
-    pka: float
+    deltaG: Annotated[float, AfterValidator(round_float(3))]
+    pka: Annotated[float, AfterValidator(round_float(3))]
 
 
 class pKaWorkflow(Workflow):
@@ -26,5 +28,5 @@ class pKaWorkflow(Workflow):
     structures: list[DBCalculation] = []
     conjugate_acids: list[pKaMicrostate] = []
     conjugate_bases: list[pKaMicrostate] = []
-    strongest_acid: Optional[float] = None
-    strongest_base: Optional[float] = None
+    strongest_acid: Annotated[float | None, AfterValidator(round_optional_float(3))] = None
+    strongest_base: Annotated[float | None, AfterValidator(round_optional_float(3))] = None

{stjames-0.0.49 → stjames-0.0.50}/stjames/workflows/redox_potential.py

@@ -1,7 +1,8 @@
-from typing import Any, TypeVar
+from typing import Annotated, Any, TypeVar
 
-from pydantic import ValidationInfo, field_validator, model_validator
+from pydantic import AfterValidator, ValidationInfo, field_validator, model_validator
 
+from ..base import round_optional_float
 from ..mode import Mode
 from ..solvent import Solvent
 from ..types import UUID
@@ -58,8 +59,8 @@ class RedoxPotentialWorkflow(Workflow, MultiStageOptMixin):
     anion_molecule: UUID | None = None
     cation_molecule: UUID | None = None
 
-    reduction_potential: float | None = None
-    oxidation_potential: float | None = None
+    reduction_potential: Annotated[float | None, AfterValidator(round_optional_float(6))] = None
+    oxidation_potential: Annotated[float | None, AfterValidator(round_optional_float(6))] = None
 
     @field_validator("solvent", mode="before")
     @classmethod

{stjames-0.0.49 → stjames-0.0.50}/stjames/workflows/scan.py

@@ -1,7 +1,10 @@
+from typing import Annotated
+
 import numpy as np
 from numpy.typing import NDArray
+from pydantic import AfterValidator
 
-from ..base import Base
+from ..base import Base, round_optional_float
 from ..molecule import Molecule
 from ..settings import Settings
 from ..types import UUID
@@ -11,7 +14,7 @@ from .workflow import Workflow
 class ScanPoint(Base):
     index: int
     molecule: Molecule
-    energy: float | None = None
+    energy: Annotated[float | None, AfterValidator(round_optional_float(6))] = None
     uuid: UUID | None = None
 
 

{stjames-0.0.49 → stjames-0.0.50}/stjames/workflows/spin_states.py

@@ -1,7 +1,8 @@
-from typing import Any
+from typing import Annotated, Any
 
-from pydantic import BaseModel, Field, PositiveInt, field_validator, model_validator
+from pydantic import AfterValidator, BaseModel, Field, PositiveInt, field_validator, model_validator
 
+from ..base import round_float
 from ..mode import Mode
 from ..types import UUID
 from .multistage_opt import MultiStageOptMixin
@@ -23,7 +24,7 @@ class SpinState(BaseModel):
     """
 
     multiplicity: PositiveInt
-    energy: float
+    energy: Annotated[float, AfterValidator(round_float(6))]
     calculation: list[UUID | None]
 
     def __str__(self) -> str:

stjames-0.0.50/stjames/workflows/tautomer.py

@@ -0,0 +1,21 @@
+from typing import Annotated, Optional
+
+from pydantic import AfterValidator
+
+from ..base import Base, round_float, round_optional_float
+from ..mode import Mode
+from .workflow import DBCalculation, Workflow
+
+
+class Tautomer(Base):
+    energy: Annotated[float, AfterValidator(round_float(6))]
+    weight: Annotated[Optional[float], AfterValidator(round_optional_float(6))] = None
+    predicted_relative_energy: Annotated[Optional[float], AfterValidator(round_optional_float(6))] = None
+
+    # UUIDs, optionally
+    structures: list[DBCalculation] = []
+
+
+class TautomerWorkflow(Workflow):
+    mode: Mode = Mode.CAREFUL
+    tautomers: list[Tautomer] = []

{stjames-0.0.49 → stjames-0.0.50/stjames.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: stjames
-Version: 0.0.49
+Version: 0.0.50
 Summary: standardized JSON atom/molecule encoding scheme
 Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/stjames
@@ -11,6 +11,7 @@ License-File: LICENSE
 Requires-Dist: atomium<2,>=1
 Requires-Dist: pydantic>=2.4
 Requires-Dist: numpy
+Requires-Dist: atomium<2.0,>=1.0
 
 # stjames
 

{stjames-0.0.49 → stjames-0.0.50}/stjames.egg-info/SOURCES.txt

@@ -47,9 +47,11 @@ stjames/workflows/bde.py
 stjames/workflows/conformer.py
 stjames/workflows/conformer_search.py
 stjames/workflows/descriptors.py
+stjames/workflows/docking.py
 stjames/workflows/electronic_properties.py
 stjames/workflows/fukui.py
 stjames/workflows/hydrogen_bond_basicity.py
+stjames/workflows/irc.py
 stjames/workflows/molecular_dynamics.py
 stjames/workflows/multistage_opt.py
 stjames/workflows/pka.py
@@ -62,4 +64,5 @@ tests/test_constraints.py
 tests/test_from_extxyz.py
 tests/test_molecule.py
 tests/test_pdb.py
+tests/test_rounding.py
 tests/test_settings.py

{stjames-0.0.49 → stjames-0.0.50}/stjames.egg-info/requires.txt

@@ -1,3 +1,4 @@
 atomium<2,>=1
 pydantic>=2.4
 numpy
+atomium<2.0,>=1.0

stjames-0.0.50/tests/test_rounding.py

@@ -0,0 +1,52 @@
+from stjames import Atom, Molecule, VibrationalMode
+
+
+def test_vibrational_mode_rounding() -> None:
+    test_vectors = [(1.23456789345346, 2.34567890346346, 3.45678901346346436), (4.567890126343636, 5.678901236346436, 6.7890123436436436)]
+    mode = VibrationalMode(frequency=1.1234567, reduced_mass=1.1234567, force_constant=1.1234567, displacements=test_vectors)
+
+    expected_vectors = [(1.234568, 2.345679, 3.456789), (4.567890, 5.678901, 6.789012)]
+    assert mode.displacements == expected_vectors
+    assert mode.frequency == 1.123
+    assert mode.reduced_mass == 1.123
+    assert mode.force_constant == 1.123
+
+
+def test_atom_rounding() -> None:
+    atom = Atom(atomic_number=2, position=[0.1111111112222222, 1.1111111112222222, 2.1111111112222222])
+
+    rounded_position = (0.11111111, 1.11111111, 2.11111111)
+
+    assert atom.position == rounded_position
+
+
+def test_molecule_rounding() -> None:
+    mol = Molecule(
+        charge=0,
+        multiplicity=1,
+        atoms=[Atom(atomic_number=2, position=[0.1111111112222222, 1.1111111112222222, 2.1111111112222222])],
+        energy=1.23456789345346,
+        zero_point_energy=2.34567890346346,
+        thermal_energy_corr=3.45678901346346436,
+        elapsed=4.567890126343636,
+        thermal_enthalpy_corr=3.45678901346346436,
+        thermal_free_energy_corr=3.45678901346346436,
+        homo_lumo_gap=5.12345678,
+        dipole=(1.23456789345346, 2.34567890346346, 3.45678901346346436),
+        stress=(
+            (1.23456789345346, 2.34567890346346, 3.45678901346346436),
+            (4.567890126343636, 5.678901236346436, 6.7890123436436436),
+            (4.567890126343636, 5.678901236346436, 6.7890123436436436),
+        ),
+    )
+
+    assert mol.atoms[0].position == (0.11111111, 1.11111111, 2.11111111)
+    assert mol.energy == 1.234568
+    assert mol.zero_point_energy == 2.345679
+    assert mol.thermal_energy_corr == 3.456789
+    assert mol.elapsed == 4.568
+    assert mol.thermal_enthalpy_corr == 3.456789
+    assert mol.thermal_free_energy_corr == 3.456789
+    assert mol.homo_lumo_gap == 5.123457
+    assert mol.dipole == (1.234568, 2.345679, 3.456789)
+    assert mol.stress == ((1.234568, 2.345679, 3.456789), (4.567890, 5.678901, 6.789012), (4.567890, 5.678901, 6.789012))

stjames-0.0.49/stjames/types.py

@@ -1,10 +0,0 @@
-from typing import TypeAlias
-
-UUID: TypeAlias = str
-
-Vector3D: TypeAlias = tuple[float, float, float]
-Vector3DPerAtom: TypeAlias = list[Vector3D]
-
-FloatPerAtom: TypeAlias = list[float]
-
-Matrix3x3: TypeAlias = tuple[Vector3D, Vector3D, Vector3D]

stjames-0.0.49/stjames/workflows/fukui.py

@@ -1,12 +0,0 @@
-from ..types import UUID
-from .workflow import Workflow
-
-
-class FukuiIndexWorkflow(Workflow):
-    # UUID of optimization
-    optimization: UUID | None = None
-
-    global_electrophilicity_index: float | None = None
-    fukui_positive: list[float] | None = None
-    fukui_negative: list[float] | None = None
-    fukui_zero: list[float] | None = None

stjames-0.0.49/stjames/workflows/tautomer.py

@@ -1,19 +0,0 @@
-from typing import Optional
-
-from ..base import Base
-from ..mode import Mode
-from .workflow import DBCalculation, Workflow
-
-
-class Tautomer(Base):
-    energy: float
-    weight: Optional[float] = None
-    predicted_relative_energy: Optional[float] = None
-
-    # UUIDs, optionally
-    structures: list[DBCalculation] = []
-
-
-class TautomerWorkflow(Workflow):
-    mode: Mode = Mode.CAREFUL
-    tautomers: list[Tautomer] = []