stjames 0.0.49__py3-none-any.whl → 0.0.50__py3-none-any.whl

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/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/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/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/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/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/types.py

@@ -1,4 +1,4 @@
-from typing import TypeAlias
+from typing import Callable, TypeAlias
 
 UUID: TypeAlias = str
 
@@ -8,3 +8,91 @@ 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/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/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/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/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/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/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/workflows/fukui.py

@@ -1,4 +1,9 @@
-from ..types import UUID
+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
 
 
@@ -6,7 +11,7 @@ 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
+    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/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/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/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/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/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/workflows/tautomer.py

@@ -1,14 +1,16 @@
-from typing import Optional
+from typing import Annotated, Optional
 
-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
 
 
 class Tautomer(Base):
-    energy: float
-    weight: Optional[float] = None
-    predicted_relative_energy: Optional[float] = None
+    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] = []

{stjames-0.0.49.dist-info → stjames-0.0.50.dist-info}/METADATA

@@ -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.dist-info → stjames-0.0.50.dist-info}/RECORD

@@ -1,22 +1,22 @@
 stjames/__init__.py,sha256=8kqGRUcrOQY07DHp6VJN7GEttPPTHw49QpieMeQqkwE,608
 stjames/_deprecated_solvent_settings.py,sha256=gj5j9p3zakIwSTK5_ndqBXJx--IzjZNxZ75z-wipLOo,450
-stjames/atom.py,sha256=w7q-x9xpBw4sJ1WGrWt65WAaStxhz-m7dugXCYEOpq4,2064
-stjames/base.py,sha256=hroQjvC8G88UiK520i1TDqnOlgw_ihmzevQGTO5yeUY,1215
+stjames/atom.py,sha256=hQCTMu3y30dvqjyCInnSs47DkUEnwhm_M2qB2jTD4Ik,2153
+stjames/base.py,sha256=YhmNZqFdWYD_lCw8rD2fZtt17nh8g7lUFBnGMezB-u8,1837
 stjames/basis_set.py,sha256=wI3M2q9uPf9jhKpAi4E2DrsyKzloDGLRjAlk7krdYgc,949
 stjames/calculation.py,sha256=O2LwwQ_cOLmDOGXTHA9J71YbUZXigUSbvbLA-fSVm3w,915
-stjames/compute_settings.py,sha256=N312PevuI4V2EswJSimitLB_JC92thTCGoZJjXFccxo,191
+stjames/compute_settings.py,sha256=wuYE6W4WqP3oFHwAeEp7XQ0oMz_MNLucWgrsuJ4kEFQ,268
 stjames/constraint.py,sha256=B6oV0rYjmAWr8gpi5f03gRy_uuqjUURVDVwoez5Cfbg,2442
 stjames/correction.py,sha256=ZVErCcj4TPyZeKrdvXVjHa0tFynsCaoy96QZUVxWFM8,413
 stjames/diis_settings.py,sha256=4m1EQQWBlpHhMnWopix8qOqJv7QCluvdnV9jSKJDFtE,552
 stjames/grid_settings.py,sha256=WrSNGc-8_f87YBZYt9Hh7RbhM4MweADoVzwBMcSqcsE,640
 stjames/int_settings.py,sha256=5HXp8opt5ZyY1UpmfaK7NVloWVLM5jkG0elEEqpVLUo,896
 stjames/message.py,sha256=Rq6QqmHZKecWxYH8fVyXmuoCCPZv8YinvgykSeorXSU,216
-stjames/method.py,sha256=dWlDoB5xxWqPg6pdQyEeLG7aPsg4cux9ckfaA6GVsD0,2280
+stjames/method.py,sha256=5hBHk2xQLpxZ52LwJ9FHWaqQMdFKnsbQEOxaVe6O4Go,2321
 stjames/mode.py,sha256=xw46Cc7f3eTS8i35qECi-8DocAlANhayK3w4akD4HBU,496
-stjames/molecule.py,sha256=v8NikFHfwOahXSo4VKGSqeHKI2HIoRdNjGE0GkZgNS4,10554
+stjames/molecule.py,sha256=DeNYmFdvbuKeXvLqlu-UxHMyZVK6y4j-Lw3HITGMnHw,12406
 stjames/opt_settings.py,sha256=gxXGtjy9l-Q5Wen9eO6T6HHRCuS8rfOofdVQIJj0JcI,550
 stjames/pdb.py,sha256=goigN-UO72y-nnHmNF4HWp8K_ZYfJorg6TCqWpsNQIU,4519
-stjames/periodic_cell.py,sha256=JDCyynpamggTNi_HnTnnotRbeSMBfYc-srhD-IwUnrg,996
+stjames/periodic_cell.py,sha256=eV_mArsY_MPEFSrFEsTC-CyCc6V8ITAXdk7yhjjNI7M,1080
 stjames/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 stjames/scf_settings.py,sha256=WotVgVrayQ_8PUHP39zVtG7iLT9PV41lpzruttFACP8,2356
 stjames/settings.py,sha256=NrNtHq-78BNp4RMP0tsABv4BjS5EscANakCyRdImI-A,8967
@@ -24,7 +24,7 @@ stjames/solvent.py,sha256=u037tmu-9oa21s-WEDZ7VC7nuNVjkqR2ML4JWjWSME4,1158
 stjames/status.py,sha256=wTKNcNxStoEHrxxgr_zTyN90NITa3rxMQZzOgrCifEw,332
 stjames/task.py,sha256=OLINRqe66o7t8arffilwmggrF_7TH0L79u6DhGruxV8,329
 stjames/thermochem_settings.py,sha256=ZTLz31v8Ltutde5Nfm0vH5YahWjcfFWfr_R856KffxE,517
-stjames/types.py,sha256=CPKR0g_kdFejMjGdKBjtuJRQqfmAZ-uIaSuGR1vBzCQ,245
+stjames/types.py,sha256=hw-3UBikESvN3DzfK5doZB030kIEfx9gC3yBkIbebsI,3764
 stjames/data/__init__.py,sha256=O59Ksp7AIqwOELCWymfCx7YeBzwNOGCMlGQi7tNLqiE,24
 stjames/data/bragg_radii.json,sha256=hhbn-xyZNSdmnULIjN2Cvq-_BGIZIqG243Ls_mey61w,1350
 stjames/data/elements.py,sha256=9BW01LZlyJ0H5s7Q26vUmjZIST41fwOYYrGvmPd7q0w,858
@@ -32,26 +32,28 @@ stjames/data/isotopes.json,sha256=5ba8QnLrHD_Ypv2xekv2cIRwYrX3MQ19-1FOFtt0RuU,83
 stjames/data/nist_isotopes.json,sha256=d5DNk1dX0iB1waEYIRR6JMHuA7AuYwSBEgBvb4EKyhM,14300
 stjames/data/read_nist_isotopes.py,sha256=y10FNjW43QpC45qib7VHsIghEwT7GG5rsNwHdc9osRI,3309
 stjames/data/symbol_element.json,sha256=vl_buFusTqBd-muYQtMLtTDLy2OtBI6KkBeqkaWRQrg,1186
-stjames/workflows/__init__.py,sha256=XQ89vfQxqz2cWmwcOMp_GKZFQ-RDm8B1s8PqAeQTK3g,1999
+stjames/workflows/__init__.py,sha256=cndGGw9ZGhvbbrT_1mJ1w7gNAjgwmkYGq2Fqt8ml6Hg,2180
 stjames/workflows/admet.py,sha256=V8noO0Eb7h2bDFSnj6Pxv4ILm0lGxyVRCi13hE0zmEQ,149
 stjames/workflows/basic_calculation.py,sha256=q48bpab7ZqmRTR4PsGC6bWkuxqkVdJRM8gysevTYXP0,212
-stjames/workflows/bde.py,sha256=iNrBiAUJA-VaAB-eFddApUO2xIc5PyPYXNtC2stQ_OU,9667
-stjames/workflows/conformer.py,sha256=YYwL3l7OaVeea4N9-ihghwa_ieKY6hia9LNbiTraMb0,2732
-stjames/workflows/conformer_search.py,sha256=y64WpdVZcrUit9ub-yWwJ0zNK8ofPlcjOG4K6pV6UEM,14241
+stjames/workflows/bde.py,sha256=cWsZNiNdUy5DGvu8o6bBepLZIB5ohiAD6RKoK3YSq1I,9786
+stjames/workflows/conformer.py,sha256=LnpvH5HmLCn-ddH3r1WhEYONUMX5ohZswdESEPCR6o4,2907
+stjames/workflows/conformer_search.py,sha256=ZQ3VxQoaR_aZ-KSblXooAnGMTFbvOj4IQnM70K0OXhc,13497
 stjames/workflows/descriptors.py,sha256=lRRCsGzad3nIg0wI1090ffaXB0FVh0nRRb2lNxCY0kI,281
-stjames/workflows/electronic_properties.py,sha256=0PqS04CfLM4pzx67Ph3JJTrzc1LCwDTT5E8x4_wW-g8,3888
-stjames/workflows/fukui.py,sha256=CsJ3_gvzqEqcxwYN7bnNIa37F3KlLm7obsU77TGmDgo,348
+stjames/workflows/docking.py,sha256=MvqfxCEZva91GB_w0qd68v7Dnb-F6AxzhQBsKJXkaeY,2239
+stjames/workflows/electronic_properties.py,sha256=uAIcGKKLhqoHyDgcOZulEXwTU2EjidyvOndZDYyeJEk,4003
+stjames/workflows/fukui.py,sha256=2J23RjkSOZ-40AM3AdnbJkRBGaCevkjkhnV3pVfa6lo,738
 stjames/workflows/hydrogen_bond_basicity.py,sha256=Luvov2DlDvZN06W-mU6YaN7wcIrTLwzdoWww-jNE3x4,517
+stjames/workflows/irc.py,sha256=y4KXeHPfPoT9jsroABxWyFdg6k5y3r99hdtvo8g26_A,3148
 stjames/workflows/molecular_dynamics.py,sha256=4HmYETU1VT2BA4-PqAayRZLjnj1WuYxd5bqpIyH9g5k,2465
 stjames/workflows/multistage_opt.py,sha256=0ou-UYMGIrewZIg3QZIgwS_eweYdsh2pRplxgRCqLcE,13572
-stjames/workflows/pka.py,sha256=zpR90Yv2L-D56o2mGArM8027DWpnFFnay31UR9Xh5Nc,774
-stjames/workflows/redox_potential.py,sha256=e7WOyTIC_1NPfh7amvW7YzqQezcswX9YaXT-qPiePAo,3651
-stjames/workflows/scan.py,sha256=cQ29DKlLCH7_6_1TFATnaM3ac9G1asUoRoDDlQYAfG0,860
-stjames/workflows/spin_states.py,sha256=TXHqB7ClTkkCy1Yfcsv99v2woAhT8oG1-uaF20-oMbQ,4592
-stjames/workflows/tautomer.py,sha256=owZOOfGlohxlaOG1pGpx7dVPvas8ZEnl_9Ms5F0Kpms,421
+stjames/workflows/pka.py,sha256=vSbMc7wuUKATNLq2kQyfCyX6aUthCj-XGSoXnuk4GMo,1031
+stjames/workflows/redox_potential.py,sha256=oLx3IyezOkJSXTVhtXkveC5GlsD6crR0kNDcNuSoIsg,3822
+stjames/workflows/scan.py,sha256=uNSuUmVMAV4exNvcv1viVe7930i7GZMn7RtEimnwEE8,1000
+stjames/workflows/spin_states.py,sha256=b-uCf-pHjF_JHbExeb5GdRToE0pIxP0JTd50U130ckI,4693
+stjames/workflows/tautomer.py,sha256=x3TC8hkMs87ZUodLyhce5EUzYoV276ePfPMi7ISWyNU,651
 stjames/workflows/workflow.py,sha256=tIu5naADYgYS7kdW8quvGEWHWosBcrIdcD7L86v-uMQ,976
-stjames-0.0.49.dist-info/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
-stjames-0.0.49.dist-info/METADATA,sha256=NFSiP9l2CXcYhOCEGaOQ95nXTxRxwQHSewRZit1FW88,1656
-stjames-0.0.49.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-stjames-0.0.49.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
-stjames-0.0.49.dist-info/RECORD,,
+stjames-0.0.50.dist-info/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
+stjames-0.0.50.dist-info/METADATA,sha256=RP-MVxDFYu3Ofca3znVgBwmNdbCLGVXsYzd-nniBE7c,1689
+stjames-0.0.50.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+stjames-0.0.50.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
+stjames-0.0.50.dist-info/RECORD,,