stjames 0.0.44__tar.gz → 0.0.46__tar.gz

{stjames-0.0.44/stjames.egg-info → stjames-0.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stjames
-Version: 0.0.44
+Version: 0.0.46
 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.44 → stjames-0.0.46}/pyproject.toml

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

stjames-0.0.46/stjames/constraint.py

@@ -0,0 +1,74 @@
+from typing import Optional, Self
+
+from pydantic import PositiveFloat, PositiveInt, model_validator
+
+from .base import Base, LowercaseStrEnum
+
+
+class ConstraintType(LowercaseStrEnum):
+    """Different sorts of constraints."""
+
+    BOND = "bond"
+    ANGLE = "angle"
+    DIHEDRAL = "dihedral"
+    FREEZE_ATOMS = "freeze_atoms"
+
+
+class Constraint(Base):
+    """
+    Represents a single (absolute) constraint.
+
+    :param constraint_type: which type
+    :param atoms: the atoms in question. n.b. - these are 1-indexed!
+    :param value: the value to constrain this to, leaving this blank sets the current value
+    """
+
+    constraint_type: ConstraintType
+    atoms: list[PositiveInt]  # 1-indexed
+    value: Optional[float] = None
+
+    @model_validator(mode="after")
+    def check_atom_list_length(self) -> Self:
+        match self.constraint_type:
+            case ConstraintType.BOND:
+                if len(self.atoms) != 2:
+                    raise ValueError("Bond constraint needs two atom indices!")
+            case ConstraintType.ANGLE:
+                if len(self.atoms) != 3:
+                    raise ValueError("Angle constraint needs three atom indices!")
+            case ConstraintType.DIHEDRAL:
+                if len(self.atoms) != 4:
+                    raise ValueError("Dihedral constraint needs four atom indices!")
+            case ConstraintType.FREEZE_ATOMS:
+                if len(self.atoms) == 0:
+                    raise ValueError("Can't freeze atoms without any atoms to freeze!")
+            case _:
+                raise ValueError("Unknown constraint_type!")
+
+        return self
+
+
+class PairwiseHarmonicConstraint(Base):
+    """
+    Represents a harmonic constraint, with a characteristic spring constant.
+
+    :param atoms: which atoms to apply to
+    :param force_constant: the strength of the attraction, in kcal/mol/Å
+    :param equilibrium: the distance at which force is zero
+    """
+
+    atoms: tuple[PositiveInt, PositiveInt]  # 1-indexed
+    force_constant: PositiveFloat  # kcal/mol / Å**2
+    equilibrium: PositiveFloat  # Å
+
+
+class SphericalHarmonicConstraint(Base):
+    """
+    Represents a spherical harmonic constraint to keep a system near the origin.
+
+    :param confining radius: the confining radius, in Å
+    :param force_constant: the strength of the confinement, in kcal/mol/Å
+    """
+
+    confining_radius: PositiveFloat
+    force_constant: PositiveFloat = 10  # kcal/mol / Å**2

{stjames-0.0.44 → stjames-0.0.46}/stjames/correction.py

@@ -10,5 +10,8 @@ class Correction(LowercaseStrEnum):
     # Grimme's D3 dispersion correction, *without* Becke–Johnson damping
     D3 = "d3"
 
+    # Grimme's D4 dispersion correction
+    D4 = "d4"
+
     # Grimme's geometric counterpoise correction
     GCP = "gcp"

{stjames-0.0.44 → stjames-0.0.46}/stjames/diis_settings.py

@@ -4,7 +4,7 @@ from .base import Base, LowercaseStrEnum
 
 
 class DIISStrategy(LowercaseStrEnum):
-    # regular pulay DIIS
+    # regular Pulay DIIS
     DIIS = "diis"
 
     # Hu/Yang JCP 2010 - ADIIS

stjames-0.0.46/stjames/method.py

@@ -0,0 +1,60 @@
+from typing import Literal
+
+from .base import LowercaseStrEnum
+
+
+class Method(LowercaseStrEnum):
+    HARTREE_FOCK = "hf"
+    HF3C = "hf_3c"
+
+    PBE = "pbe"
+    B973C = "b97_3c"
+    B97D3BJ = "b97_d3bj"
+    R2SCAN = "r2scan"
+    R2SCAN3C = "r2scan_3c"
+    TPSS = "tpss"
+    M06L = "m06l"
+
+    PBE0 = "pbe0"
+    B3LYP = "b3lyp"
+    TPSSH = "tpssh"
+    M06 = "m06"
+    M062X = "m062x"
+
+    CAMB3LYP = "camb3lyp"
+    WB97XD3 = "wb97x_d3"
+    WB97XV = "wb97x_v"
+    WB97MV = "wb97m_v"
+    WB97MD3BJ = "wb97m_d3bj"
+    WB97X3C = "wb97x_3c"
+
+    DSDBLYPD3BJ = "dsd_blyp_d3bj"
+
+    AIMNET2_WB97MD3 = "aimnet2_wb97md3"
+    MACE_MP_0 = "mace_mp_0"
+    OCP24_S = "ocp24_s"
+    OCP24_L = "ocp24_l"
+
+    GFN_FF = "gfn_ff"
+    GFN0_XTB = "gfn0_xtb"
+    GFN1_XTB = "gfn1_xtb"
+    GFN2_XTB = "gfn2_xtb"
+
+    # this was going to be removed, but Jonathon wrote such a nice basis set test... it's off the front end.
+    BP86 = "bp86"
+
+
+NNPMethod = Literal[Method.AIMNET2_WB97MD3]
+NNP_METHODS = [Method.AIMNET2_WB97MD3]
+
+XTBMethod = Literal[Method.GFN_FF, Method.GFN0_XTB, Method.GFN1_XTB, Method.GFN2_XTB]
+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]
+
+PrepackagedMethod = XTBMethod | CompositeMethod | NNPMethod
+PREPACKAGED_METHODS = [*XTB_METHODS, *COMPOSITE_METHODS]
+
+MethodWithCorrection = Literal[Method.WB97XD3, Method.WB97XV, Method.WB97MV, Method.WB97MD3BJ, Method.DSDBLYPD3BJ]
+METHODS_WITH_CORRECTION = [Method.WB97XD3, Method.WB97XV, Method.WB97MV, Method.WB97MD3BJ, Method.DSDBLYPD3BJ, Method.B97D3BJ]

{stjames-0.0.44 → stjames-0.0.46}/stjames/molecule.py

@@ -8,7 +8,7 @@ from pydantic import NonNegativeInt, PositiveInt, ValidationError
 from .atom import Atom
 from .base import Base
 from .periodic_cell import PeriodicCell
-from .types import Matrix3x3, Vector3D, Vector3DPerAtom
+from .types import FloatPerAtom, Matrix3x3, Vector3D, Vector3DPerAtom
 
 
 class MoleculeReadError(RuntimeError):
@@ -18,10 +18,8 @@ class MoleculeReadError(RuntimeError):
 class VibrationalMode(Base):
     frequency: float  # in cm-1
     reduced_mass: float  # amu
-
-    # todo - check units here?
-    force_constant: float
-    displacements: Vector3DPerAtom
+    force_constant: float  # mDyne/Å
+    displacements: Vector3DPerAtom  # Å
 
 
 class Molecule(Base):
@@ -44,8 +42,8 @@ class Molecule(Base):
 
     velocities: Optional[Vector3DPerAtom] = None  # Å/fs
 
-    mulliken_charges: Optional[list[float]] = None
-    mulliken_spin_densities: Optional[list[float]] = None
+    mulliken_charges: FloatPerAtom | None = None
+    mulliken_spin_densities: FloatPerAtom | None = None
     dipole: Optional[Vector3D] = None  # in Debye
 
     vibrational_modes: Optional[list[VibrationalMode]] = None

{stjames-0.0.44 → stjames-0.0.46}/stjames/scf_settings.py

@@ -20,7 +20,7 @@ class SCFInitMethod(LowercaseStrEnum):
 class OrthonormalizationMethod(LowercaseStrEnum):
     SYMMETRIC = "symmetric"
     CANONICAL = "canonical"
-    # cholesky, in future?
+    # Cholesky, in future?
 
 
 class SCFSettings(Base):

{stjames-0.0.44 → stjames-0.0.46}/stjames/types.py

@@ -5,4 +5,6 @@ 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.46/stjames/workflows/__init__.py

@@ -0,0 +1,55 @@
+# ruff: noqa: F405
+from typing import Literal
+
+from .admet import *
+from .basic_calculation import *
+from .bde import *
+from .conformer import *
+from .conformer_search import *
+from .descriptors import *
+from .electronic_properties import *
+from .fukui import *
+from .molecular_dynamics import *
+from .multistage_opt import *
+from .pka import *
+from .redox_potential import *
+from .scan import *
+from .spin_states import *
+from .tautomer import *
+from .workflow import Workflow
+
+WORKFLOW_NAME = Literal[
+    "admet",
+    "basic_calculation",
+    "bde",
+    "conformers",
+    "conformer_search",
+    "descriptors",
+    "electronic_properties",
+    "fukui",
+    "molecular_dynamics",
+    "multistage_opt",
+    "pka",
+    "redox_potential",
+    "scan",
+    "spin_states",
+    "tautomers",
+]
+
+WORKFLOW_MAPPING: dict[str, Workflow] = {
+    "admet": ADMETWorkflow,  # type: ignore [dict-item]
+    "basic_calculation": BasicCalculationWorkflow,  # type: ignore [dict-item]
+    "bde": BDEWorkflow,  # type: ignore [dict-item]
+    "conformers": ConformerWorkflow,  # type: ignore [dict-item]
+    "conformer_search": ConformerSearchWorkflow,  # type: ignore [dict-item]
+    "descriptors": DescriptorsWorkflow,  # type: ignore [dict-item]
+    "electronic_properties": ElectronicPropertiesWorkflow,  # type: ignore [dict-item]
+    "fukui": FukuiIndexWorkflow,  # type: ignore [dict-item]
+    "molecular_dynamics": MolecularDynamicsWorkflow,  # type: ignore [dict-item]
+    "multistage_opt": MultiStageOptWorkflow,  # type: ignore [dict-item]
+    "pka": pKaWorkflow,  # type: ignore [dict-item]
+    "redox_potential": RedoxPotentialWorkflow,  # type: ignore [dict-item]
+    "scan": ScanWorkflow,  # type: ignore [dict-item]
+    "spin_states": SpinStatesWorkflow,  # type: ignore [dict-item]
+    "tautomers": TautomerWorkflow,  # type: ignore [dict-item]
+}

{stjames-0.0.44 → stjames-0.0.46}/stjames/workflows/bde.py

@@ -58,12 +58,12 @@ class BDEWorkflow(Workflow, MultiStageOptMixin):
     :param initial_molecule: Molecule of interest
     :param mode: Mode for workflow
     :param multistage_opt_settings: set by mode unless mode=MANUAL (ignores additional settings if set)
-    :param solvent: solvent to use
+    :param solvent: solvent to use for singlepoint
     :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
+    :param frequencies: whether to calculate frequencies
 
     Overridden:
     :param mso_mode: Mode for MultiStageOptSettings
-    :param frequencies: whether to calculate frequencies
 
     Turned off:
     :param constraints: constraints to add (not supported)
@@ -81,7 +81,6 @@ class BDEWorkflow(Workflow, MultiStageOptMixin):
     """
 
     mso_mode: Mode = _sentinel_mso_mode  # type: ignore [assignment]
-    frequencies: bool = False
     optimize_fragments: bool = None  # type: ignore [assignment]
 
     atoms: tuple[PositiveInt, ...] = Field(default_factory=tuple)
@@ -106,6 +105,10 @@ class BDEWorkflow(Workflow, MultiStageOptMixin):
         """
         return f"{type(self).__name__} {self.mode.name}\n" + "\n".join(map(str, self.fragment_indices))
 
+    @property
+    def level_of_theory(self) -> str:
+        return self.multistage_opt_settings.level_of_theory
+
     @property
     def energies(self) -> tuple[float | None, ...]:
         return tuple(bde.energy for bde in self.bdes)

stjames-0.0.46/stjames/workflows/conformer_search.py

@@ -0,0 +1,352 @@
+"""Conformer Search Workflow."""
+
+from abc import ABC
+from typing import Self, Sequence, TypeVar
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from ..base import LowercaseStrEnum
+from ..constraint import Constraint
+from ..method import Method, XTBMethod
+from ..mode import Mode
+from ..types import UUID
+from .multistage_opt import MultiStageOptMixin
+from .workflow import Workflow
+
+_sentinel = object()
+
+_T = TypeVar("_T")
+_U = TypeVar("_U")
+
+
+def check_sentinel(value: _T, default: _U) -> _T | _U:
+    """Return value unless _sentinel, then return default."""
+    return default if value is _sentinel else value
+
+
+class ScreeningSettings(BaseModel):
+    """
+    Settings for determining unique and useful conformers.
+
+    :param energy_threshold: maximum relative energy for screening
+    :param rotational_constants_threshold: maximum difference in rotational constants for screening
+    :param rmsd: Cartesian RMSD for screening
+    :param max_confs: maximum number of conformers to keep
+    """
+
+    energy_threshold: float | None = None  # kcal/mol
+    rotational_constants_threshold: float | None = 0.02
+    rmsd: float | None = 0.25
+    max_confs: int | None = None
+
+
+class ConformerGenSettings(BaseModel):
+    """
+    Conformer generation settings.
+
+    Conformers are generated and an initial screening is performed to remove duplicates and high-energy conformers.
+
+    :param mode: Mode for calculations
+    :param conf_opt_method: method for the optimization
+    :param screening: post-generation screening settings
+    :param constraints: constraints for conformer generation
+    :param nci: add a constraining potential for non-covalent interactions
+    :param max_confs: maximum number of conformers to keep
+    """
+
+    mode: Mode = Mode.RAPID
+    conf_opt_method: XTBMethod = Method.GFN_FF
+    screening: ScreeningSettings | None = None
+    constraints: Sequence[Constraint] = tuple()
+    nci: bool = False
+    max_confs: int | None = None
+
+    def __str__(self) -> str:
+        """Return a string representation of the ConformerGenSettings."""
+        return repr(self)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the ConformerGenSettings."""
+        return f"<{type(self).__name__} {self.mode.name}>"
+
+
+class ETKDGSettings(ConformerGenSettings):
+    """
+    Settings for ETKDG conformer generation.
+
+    Inherited:
+    :param mode: Mode for calculations
+    :param conf_opt_method: method for the optimization
+    :param screening: post-generation screening settings
+    :param constraints: constraints for conformer generation
+    :param nci: add a constraining potential for non-covalent interactions (not supported in ETKDG)
+    :param max_confs: maximum number of conformers to keep
+
+    New:
+    :param num_initial_confs: number of initial conformers to generate
+    :param num_confs_considered: number of conformers to consider for optimization
+    :param num_confs_taken: number of final conformers to take
+    :param max_mmff_energy: MMFF energy cutoff
+    :param max_mmff_iterations: MMFF optimization iterations
+    """
+
+    num_initial_confs: int = 300
+    num_confs_considered: int = 100
+    max_mmff_iterations: int = 500
+    max_mmff_energy: float | None = 30
+
+    @field_validator("constraints")
+    def check_constraints(cls, constraints: Sequence[Constraint]) -> Sequence[Constraint]:
+        if constraints:
+            raise ValueError("ETKDG does not support constraints")
+
+        return tuple(constraints)
+
+    @field_validator("nci")
+    def check_nci(cls, nci: bool) -> bool:
+        if nci:
+            raise ValueError("ETKDG does not support NCI")
+
+        return nci
+
+    @model_validator(mode="after")
+    def validate_and_build(self) -> Self:
+        match self.mode:
+            case Mode.MANUAL:
+                pass
+            case Mode.RECKLESS:
+                self.num_initial_confs = 200
+                self.num_confs_considered = 50
+                self.max_confs = 20 if self.max_confs is None else self.max_confs
+                self.max_mmff_energy = 20
+            case Mode.RAPID:
+                self.max_confs = 50 if self.max_confs is None else self.max_confs
+                self.conf_opt_method = Method.GFN0_XTB
+            case _:
+                raise NotImplementedError(f"Unsupported mode: {self.mode}")
+
+        return self
+
+
+class iMTDSpeeds(LowercaseStrEnum):
+    MEGAQUICK = "megaquick"
+    SUPERQUICK = "superquick"
+    QUICK = "quick"
+    NORMAL = "normal"
+    EXTENSIVE = "extensive"
+
+
+class iMTDSettings(ConformerGenSettings, ABC):
+    """
+    Settings for iMTD style conformer generation.
+
+    RECKLESS:
+        - GFN-FF//MTD(GFN-FF)
+        - Megaquick
+            - No GC
+            - No rotamer metadynamics
+            - Energy window = 5.0
+            - Run scaling factor = 0.5
+            - 6 MTD runs
+    RAPID:
+        - GFN0//MTD(GFN-FF)
+        - Superquick
+            - No GC
+            - No rotamer metadynamics
+            - Energy window = 5.0
+            - Run scaling factor = 0.5
+            - 6 MTD runs
+    CAREFUL:
+        - GFN2//MTD(GFN-FF)
+        - Quick
+            - GC (for iMTD-GC)
+            - Rotamer metadynamics (for iMTD-GC)
+            - Energy window = 5.0
+            - Run scaling factor = 0.5
+            - 6 MTD runs
+    METICULOUS:
+        - GFN2//MTD(GFN2)
+        - "Normal"
+            - GC (for iMTD-GC)
+            - Rotamer metadynamics (for iMTD-GC)
+            - Energy window = 6.0
+            - Run scaling factor = 1
+            - 14 MTD runs (2 with extreme values)
+
+
+    See https://github.com/crest-lab/crest/blob/5ca82feb2ec4df30a0129db957163c934f085952/src/choose_settings.f90#L202
+    and https://github.com/crest-lab/crest/blob/5ca82feb2ec4df30a0129db957163c934f085952/src/confparse.f90#L825
+    for how quick, superquick, and megaquick are defined.
+
+    Additional notes:
+        Extensive mode
+        - GC
+        - Rotamer metadynamics
+        - Energy window = 8.0
+        - Run scaling factor = 2
+        - 14 MTD runs (2 with extreme values)
+
+        --NCI may switch things to QUICK?
+
+    Inherited:
+    :param mode: Mode for calculations
+    :param conf_opt_method: method for the optimization
+    :param screening: post-generation screening settings (not used)
+    :param constraints: constraints to add
+    :param nci: add an ellipsoide potential around the input structure
+    :param max_confs: maximum number of conformers to keep
+
+    New:
+    :param mtd_method: method for the metadynamics
+    :param speed: speed of the calculations (CREST specific setting)
+    :param reopt: re-optimize conformers (corrects for the lack of rotamer metadynamics and GC)
+    :param free_energy_weights: calculate frequencies and re-weight based on free energies
+    """
+
+    mtd_method: XTBMethod = Method.GFN_FF
+    mtd_runtype: str = "imtd-gc"
+
+    speed: iMTDSpeeds = iMTDSpeeds.QUICK
+    reopt: bool = _sentinel  # type: ignore [assignment]
+    free_energy_weights: bool = False
+
+    @model_validator(mode="after")
+    def validate_and_build_imtdgc_settings(self) -> Self:
+        match self.mode:
+            case Mode.MANUAL:
+                if self.reopt is _sentinel:
+                    raise ValueError("Must specify reopt with MANUAL mode")
+            case Mode.RECKLESS:  # GFN-FF//MTD(GFN-FF)
+                self.max_confs = 20 if self.max_confs is None else self.max_confs
+                self.speed = iMTDSpeeds.MEGAQUICK
+                self.reopt = check_sentinel(self.reopt, True)
+            case Mode.RAPID:  # GFN0//MTD(GFN-FF)
+                self.max_confs = 50 if self.max_confs is None else self.max_confs
+                self.speed = iMTDSpeeds.SUPERQUICK
+                self.conf_opt_method = Method.GFN0_XTB
+                self.reopt = check_sentinel(self.reopt, True)
+            case Mode.CAREFUL:  # GFN2//MTD(GFN-FF)
+                self.speed = iMTDSpeeds.QUICK
+                self.conf_opt_method = Method.GFN2_XTB
+                self.reopt = check_sentinel(self.reopt, False)
+            case Mode.METICULOUS:  # GFN2//MTD(GFN2)
+                self.speed = iMTDSpeeds.NORMAL
+                self.mtd_method = Method.GFN2_XTB
+                self.conf_opt_method = Method.GFN2_XTB
+                self.reopt = check_sentinel(self.reopt, False)
+            # case Mode.EXTREME: # GFN2//MTD(GFN2)
+            #     self.mtd_method = Method.GFN2_XTB
+            #     self.conf_opt_method = Method.GFN2_XTB
+            #     self.speed = iMTDSpeeds.EXTENSIVE
+            #     self.reopt = check_sentinel(self.reopt, False)
+            case _:
+                raise NotImplementedError(f"Unsupported mode: {self.mode}")
+
+        return self
+
+
+class iMTDGCSettings(iMTDSettings):
+    run_type: str = "imtdgc"
+
+
+class iMTDsMTDSettings(iMTDSettings):
+    run_type: str = "imtd-smtd"
+
+
+class ConformerGenMixin(BaseModel):
+    """
+    Mixin for workflows that need conformer generation.
+
+    :param conf_gen_mode: Mode for calculations
+    :param conf_gen_settings: settings for conformer generation
+    :param constraints: constraints to add
+    :param nci: add a constraining potential for non-covalent interactions
+    :param max_confs: maximum number of conformers to keep
+    """
+
+    conf_gen_mode: Mode = Mode.RAPID
+    conf_gen_settings: ConformerGenSettings = _sentinel  # type: ignore [assignment]
+    constraints: Sequence[Constraint] = tuple()
+    nci: bool = False
+    max_confs: int | None = None
+
+    @model_validator(mode="after")
+    def validate_and_build_conf_gen_settings(self) -> Self:
+        """Validate and build the ConformerGenSettings."""
+        if self.conf_gen_settings is not _sentinel and self.conf_gen_mode != Mode.MANUAL:
+            raise ValueError("Cannot specify conf_gen_settings with non-MANUAL mode")
+
+        match self.conf_gen_mode:
+            case Mode.MANUAL:
+                if self.conf_gen_settings is _sentinel:
+                    raise ValueError("Must specify conf_gen_settings with MANUAL mode")
+
+            case Mode.RECKLESS | Mode.RAPID:
+                # ETKDGSettings will error if constraints or nci are set
+                self.conf_gen_settings = ETKDGSettings(mode=self.conf_gen_mode, constraints=self.constraints, nci=self.nci, max_confs=self.max_confs)
+            case Mode.CAREFUL | Mode.METICULOUS:
+                self.conf_gen_settings = iMTDSettings(mode=self.conf_gen_mode, constraints=self.constraints, nci=self.nci, max_confs=self.max_confs)
+
+            case _:
+                raise NotImplementedError(f"Unsupported mode: {self.conf_gen_mode}")
+
+        return self
+
+
+class ConformerSearchMixin(ConformerGenMixin, MultiStageOptMixin):
+    """
+    Mixin for workflows that need conformer search—a combination of conformer generation and optimization.
+
+    Inherited (ConformerGenMixin):
+    :param conf_gen_mode: Mode for conformer generation
+    :param mso_mode: Mode for MultiStageOptSettings
+    :param conf_gen_settings: settings for conformer generation
+    :param nci: add a constraining potential for non-covalent interactions
+
+    Inherited (MultiStageOptMixin):
+    :param multistage_opt_settings: set by mso_mode unless mode=MANUAL (ignores additional settings if set)
+    :param solvent: solvent to use
+    :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
+    :param transition_state: whether this is a transition state
+    :param frequencies: whether to calculate frequencies
+
+    Inherited (Both):
+    :param constraints: constraints to add (diamond inheritance, works as expected)
+    """
+
+    def __str__(self) -> str:
+        """Return a string representation of the ConformerSearch workflow."""
+        return repr(self)
+
+    def __repr__(self) -> str:
+        """Return a string representation of the ConformerSearch workflow."""
+        return f"<{type(self).__name__} {self.conf_gen_mode.name} {self.mso_mode.name}>"
+
+
+class ConformerSearchWorkflow(ConformerSearchMixin, Workflow):
+    """
+    ConformerSearch Workflow.
+
+    Inherited:
+    :param initial_molecule: Molecule of interest
+    :param conf_gen_mode: Mode for calculations
+    :param conf_gen_settings: settings for conformer generation
+    :param mso_mode: Mode for MultiStageOptSettings
+    :param multistage_opt_settings: set by mode unless mode=MANUAL (ignores additional settings if set)
+    :param solvent: solvent to use
+    :param xtb_preopt: pre-optimize with xtb (sets based on mode when None)
+    :param constraints: constraints to add
+    :param transition_state: whether this is a transition state
+    :param frequencies: whether to calculate frequencies
+
+    Ignored:
+    :param mode: Mode to use (not used)
+
+    New:
+    :param conformer_uuids: list of UUIDs of the Molecules generated
+    :param energies: energies of the molecules
+    """
+
+    # Results
+    conformer_uuids: list[list[UUID | None]] = Field(default_factory=list)
+    energies: list[float] = Field(default_factory=list)

{stjames-0.0.44 → stjames-0.0.46}/stjames/workflows/descriptors.py

@@ -5,7 +5,7 @@ Descriptors = dict[str, dict[str, float] | tuple[float | None, ...] | float]
 
 
 class DescriptorsWorkflow(Workflow):
-    # uuid of optimization
+    # UUID of optimization
     optimization: UUID | None = None
 
     descriptors: Descriptors | None = None