stjames 0.0.44__py3-none-any.whl → 0.0.45__py3-none-any.whl

stjames/constraint.py

@@ -1,4 +1,6 @@
-from pydantic import PositiveFloat, PositiveInt
+from typing import Optional, Self
+
+from pydantic import PositiveFloat, PositiveInt, model_validator
 
 from .base import Base, LowercaseStrEnum
 
@@ -12,25 +14,57 @@ class ConstraintType(LowercaseStrEnum):
 
 
 class Constraint(Base):
-    """Represents a single (absolute) constraint."""
+    """
+    Represents a single (absolute) constraint.
+
+    :param constraint_type: which type
+    :param atoms: the atoms in question
+    :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 _:
+                raise ValueError("Unknown constraint_type!")
+
+        return self
 
 
 class PairwiseHarmonicConstraint(Base):
     """
     Represents a harmonic constraint, with a characteristic spring constant.
+
+    :param atoms: whch 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
-    spring_constant: PositiveFloat  # kcal/mol / Å**2
+    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
-    confining_force_constant: PositiveFloat = 10  # kcal/mol / Å**2
+    force_constant: PositiveFloat = 10  # kcal/mol / Å**2

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

@@ -1,3 +1,5 @@
+from typing import Literal
+
 from .base import LowercaseStrEnum
 
 
@@ -7,6 +9,7 @@ class Method(LowercaseStrEnum):
 
     PBE = "pbe"
     B973C = "b97_3c"
+    B97D3BJ = "b97_d3bj"
     R2SCAN = "r2scan"
     R2SCAN3C = "r2scan_3c"
     TPSS = "tpss"
@@ -28,6 +31,9 @@ class Method(LowercaseStrEnum):
     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"
@@ -38,34 +44,17 @@ class Method(LowercaseStrEnum):
     BP86 = "bp86"
 
 
-MLFF = [
-    Method.AIMNET2_WB97MD3,
-]
-
-XTB_METHODS = [
-    Method.GFN_FF,
-    Method.GFN0_XTB,
-    Method.GFN1_XTB,
-    Method.GFN2_XTB,
-]
-
-COMPOSITE_METHODS = [
-    Method.HF3C,
-    Method.B973C,
-    Method.R2SCAN3C,
-    Method.WB97X3C,
-]
-
-PREPACKAGED_METHODS = [
-    *MLFF,
-    *XTB_METHODS,
-    *COMPOSITE_METHODS,
-]
-
-METHODS_WITH_CORRECTION = [
-    Method.WB97XD3,
-    Method.WB97XV,
-    Method.WB97MV,
-    Method.WB97MD3BJ,
-    Method.DSDBLYPD3BJ,
-]
+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/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/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/workflows/__init__.py

@@ -2,6 +2,7 @@ from .admet import *
 from .basic_calculation import *
 from .bde import *
 from .conformer import *
+from .conformer_search import *
 from .descriptors import *
 from .fukui import *
 from .molecular_dynamics import *

stjames/workflows/bde.py

@@ -58,7 +58,7 @@ 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)
 
     Overridden:
@@ -106,6 +106,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/workflows/conformer_search.py

@@ -0,0 +1,345 @@
+"""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 determing unique and useful conformers.
+
+    :param energy_threshhold: maximum relative energy for screening
+    :param rotational_constants_threshhold: maximum difference in rotational constants for screening
+    :param rmsd: cartesian RMSD for screening
+    :param max_confs: maximum number of conformers to keep
+    """
+
+    energy_threshhold: float | None = None  # kcal/mol
+    rotational_constants_threshhold: 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 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 conf_opt_method: method for the optimization
+
+    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
+    :param max_confs: maximum number of conformers to keep
+    """
+
+    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 _sentinel else self.max_confs
+                self.max_mmff_energy = 20
+            case Mode.RAPID:
+                self.max_confs = 50 if self.max_confs is _sentinel 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
+
+    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 _sentinel 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 _sentinel 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
+    """
+
+    conf_gen_mode: Mode = Mode.RAPID
+    conf_gen_settings: ConformerGenSettings = _sentinel  # type: ignore [assignment]
+    constraints: Sequence[Constraint] = tuple()
+
+    @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 added
+                self.conf_gen_settings = ETKDGSettings(mode=self.conf_gen_mode, constraints=self.constraints)
+            case Mode.CAREFUL | Mode.METICULOUS:
+                self.conf_gen_settings = iMTDSettings(mode=self.conf_gen_mode, constraints=self.constraints)
+
+            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:
+    :param conf_gen_mode: Mode for conformer generation
+    :param mso_mode: Mode for MultiStageOptSettings
+    :param conf_gen_settings: settings for conformer generation
+    :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 constraints: constraints to add (diamond inheritance, works as expected)
+    :param transition_state: whether this is a transition state
+
+    Overridden:
+    :param frequencies: whether to calculate frequencies (turned off)
+    """
+
+    frequencies: bool = False
+
+    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 (turned off)
+
+    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/workflows/electronic_properties.py

@@ -0,0 +1,86 @@
+from pydantic import NonNegativeFloat, NonNegativeInt
+
+from ..base import Base
+from ..settings import Settings
+from ..types import UUID, FloatPerAtom, Matrix3x3, Vector3D
+from .workflow import Workflow
+
+
+class PropertyCubePoint(Base):
+    x: float
+    y: float
+    z: float
+    val: float
+
+
+class PropertyCube(Base):
+    """
+    Represents a "cubefile" of some property.
+    """
+
+    cube_data: list[PropertyCubePoint]
+
+
+class MolecularOrbitalCube(PropertyCube):
+    """
+    Inherits `cube_data`.
+    """
+
+    occupation: NonNegativeInt
+    energy: float
+
+
+class ElectronicPropertiesWorkflow(Workflow):
+    """
+    Workflow for computing electronic properties!
+
+    Inherited
+    :param initial_molecule: molecule of interest
+
+    Config settings:
+    :param settings: the level of theory to use
+    :param compute_density_cube: whether or not to compute the density on a cube
+    :param compute_electrostatic_potential_cube: whether or not to compute the electrostatic potential on a cube
+    :param compute_num_occupied_orbitals: how many occupied orbitals to save
+    :param compute_num_virtual_orbitals: how many virtual orbitals to save
+
+    Populated while running:
+    :param calculation: the UUID of the calculation
+    :param dipole: the dipole moment
+    :param quadrupole: the quadrupole moment
+    :param mulliken_charges: the Mulliken charges
+    :param lowdin_charges: the Lowdin charges
+    :param wiberg_bond_orders: the Wiberg bond orders (`atom1`, `atom2`, `order`)
+    :param mayer_bond_orders: the Mayer bond orders (`atom1`, `atom2`, `order`)
+    :param density_cube: the electron density, as a cube
+    :param electrostatic_potential_cube: the electrostatic potential, as a cube
+    :param molecular_orbitals_alpha: for open-shell species (UHF/ROHF), a dict containing the alpha MOs
+        (The key is the absolute orbital index.)
+    :param molecular_orbitals_beta: for open-shell species (UHF/ROHF), a dict containing the beta MOs
+        (The key is the absolute orbital index.)
+    :param molecular_orbitals: for closed-shell species (RHF), a dict containing the MOs
+        (The key is the absolute orbital index.)
+    """
+
+    settings: Settings
+    compute_density_cube: bool = True
+    compute_electrostatic_potential_cube: bool = True
+    compute_num_occupied_orbitals: NonNegativeInt = 1
+    compute_num_virtual_orbitals: NonNegativeInt = 1
+
+    calculation: UUID | None = None
+
+    dipole: Vector3D | None = None
+    quadrupole: Matrix3x3 | None = None
+
+    mulliken_charges: FloatPerAtom | None = None
+    lowdin_charges: FloatPerAtom | None = None
+
+    wiberg_bond_orders: list[tuple[NonNegativeInt, NonNegativeInt, NonNegativeFloat]] = []
+    mayer_bond_orders: list[tuple[NonNegativeInt, NonNegativeInt, NonNegativeFloat]] = []
+
+    density_cube: PropertyCube | None = None
+    electrostatic_potential_cube: PropertyCube | None = None
+    molecular_orbitals_alpha: dict[NonNegativeInt, MolecularOrbitalCube] = {}
+    molecular_orbitals_beta: dict[NonNegativeInt, MolecularOrbitalCube] = {}
+    molecular_orbitals: dict[NonNegativeInt, MolecularOrbitalCube] = {}

stjames/workflows/molecular_dynamics.py

@@ -9,6 +9,11 @@ from ..types import UUID
 from .workflow import Workflow
 
 
+class MolecularDynamicsInitialization(LowercaseStrEnum):
+    RANDOM = "random"
+    QUASICLASSICAL = "quasiclassical"
+
+
 class ThermodynamicEnsemble(LowercaseStrEnum):
     NPT = "npt"
     NVT = "nvt"
@@ -18,22 +23,24 @@ class ThermodynamicEnsemble(LowercaseStrEnum):
 class Frame(Base):
     index: int  # what number frame this is within the MD simulation
 
-    uuid: UUID | None = None  # UUID of molecule
+    calculation_uuid: UUID | None = None  # UUID of calculation
 
     pressure: float
     temperature: float
+    volume: float
     energy: float
 
 
 class MolecularDynamicsSettings(Base):
     ensemble: ThermodynamicEnsemble = ThermodynamicEnsemble.NVT
+    initialization: MolecularDynamicsInitialization = MolecularDynamicsInitialization.RANDOM
 
     timestep: PositiveFloat = 1.0  # fs
     num_steps: PositiveInt = 500
 
     confining_constraint: SphericalHarmonicConstraint | None = None
 
-    temperature: PositiveFloat | None = 300  # K
+    temperature: PositiveFloat = 300  # K
     pressure: PositiveFloat | None = None  # atm
 
     langevin_thermostat_timescale: PositiveFloat = 100  # fs
@@ -46,7 +53,7 @@ class MolecularDynamicsSettings(Base):
         """Check that NVT ensemble always has temperature defined, and that NPT has temp and pressure defined."""
         if self.ensemble == ThermodynamicEnsemble.NVT and self.temperature is None:
             raise ValueError("NVT ensemble must have a temperature defined")
-        if self.ensemble == ThermodynamicEnsemble.NPT and (self.temperature is None or self.pressure is None):
+        elif self.ensemble == ThermodynamicEnsemble.NPT and (self.temperature is None or self.pressure is None):
             raise ValueError("NPT ensemble must have both temperature and pressure defined")
         return self
 

stjames/workflows/multistage_opt.py

@@ -27,14 +27,14 @@ class MultiStageOptSettings(BaseModel):
         wB97M-D3BJ/def2-TZVPPD//wB97X-3c//r²SCAN-3c with GFN2-xTB pre-opt
 
     Notes:
-    - No solvent in pre-opt
+    - No solvent in any optimizations when using Modes
     - If solvent: xTB singlepoints use CPCMX, xTB optimizations use ALBP, all else use CPCM
     - Allows a single point to be called with no optimization
 
     :param mode: Mode for settings
     :param optimization_settings: list of opt settings to apply successively
     :param singlepoint_settings: final single point settings
-    :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 constraints: constraints for optimization
     :param transition_state: whether this is a transition state
@@ -44,7 +44,7 @@ class MultiStageOptSettings(BaseModel):
     >>> msos
     <MultiStageOptSettings RAPID>
     >>> msos.level_of_theory
-    'r2scan_3c/cpcm(water)//gfn2_xtb/alpb(water)'
+    'r2scan_3c/cpcm(water)//gfn2_xtb'
     """
 
     mode: Mode
@@ -78,7 +78,7 @@ class MultiStageOptSettings(BaseModel):
 
         >>> msos = MultiStageOptSettings(mode=Mode.RAPID, solvent="hexane")
         >>> msos.level_of_theory
-        'r2scan_3c/cpcm(hexane)//gfn2_xtb/alpb(hexane)'
+        'r2scan_3c/cpcm(hexane)//gfn2_xtb'
         """
         methods = [self.singlepoint_settings] if self.singlepoint_settings else []
         methods += reversed(self.optimization_settings)
@@ -148,14 +148,14 @@ class MultiStageOptSettings(BaseModel):
         match mode:
             case Mode.RECKLESS:
                 self.xtb_preopt = False
-                self.optimization_settings = [opt(Method.GFN_FF, solvent=self.solvent, freq=self.frequencies)]
+                self.optimization_settings = [opt(Method.GFN_FF, freq=self.frequencies)]
                 self.singlepoint_settings = sp(Method.GFN2_XTB, solvent=self.solvent)
 
             case Mode.RAPID:
                 self.xtb_preopt = bool(self.xtb_preopt)
                 self.optimization_settings = [
                     *gfn0_pre_opt * self.xtb_preopt,
-                    opt(Method.GFN2_XTB, solvent=self.solvent, freq=self.frequencies),
+                    opt(Method.GFN2_XTB, freq=self.frequencies),
                 ]
                 self.singlepoint_settings = sp(Method.R2SCAN3C, solvent=self.solvent)
 
@@ -163,7 +163,7 @@ class MultiStageOptSettings(BaseModel):
                 self.xtb_preopt = (self.xtb_preopt is None) or self.xtb_preopt
                 self.optimization_settings = [
                     *gfn2_pre_opt * self.xtb_preopt,
-                    opt(Method.R2SCAN3C, solvent=self.solvent, freq=self.frequencies),
+                    opt(Method.R2SCAN3C, freq=self.frequencies),
                 ]
                 self.singlepoint_settings = sp(Method.WB97X3C, solvent=self.solvent)
 
@@ -171,8 +171,8 @@ class MultiStageOptSettings(BaseModel):
                 self.xtb_preopt = (self.xtb_preopt is None) or self.xtb_preopt
                 self.optimization_settings = [
                     *gfn2_pre_opt * self.xtb_preopt,
-                    opt(Method.R2SCAN3C, solvent=self.solvent),
-                    opt(Method.WB97X3C, solvent=self.solvent, freq=self.frequencies),
+                    opt(Method.R2SCAN3C),
+                    opt(Method.WB97X3C, freq=self.frequencies),
                 ]
                 self.singlepoint_settings = sp(Method.WB97MD3BJ, "def2-TZVPPD", solvent=self.solvent)
 
@@ -191,7 +191,7 @@ class MultiStageOptWorkflow(Workflow, MultiStageOptSettings):
     :param mode: Mode for workflow
     :param optimization_settings: list of opt settings to apply successively
     :param singlepoint_settings: final single point settings
-    :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 constraints: constraints for optimization
     :param transition_state: whether this is a transition state
@@ -206,7 +206,7 @@ class MultiStageOptWorkflow(Workflow, MultiStageOptSettings):
     >>> msow
     <MultiStageOptWorkflow RAPID>
     >>> msow.level_of_theory
-    'r2scan_3c/cpcm(water)//gfn2_xtb/alpb(water)'
+    'r2scan_3c/cpcm(water)//gfn2_xtb'
     """
 
     # Populated while running the workflow
@@ -228,7 +228,7 @@ class MultiStageOptMixin(BaseModel):
     Mixin for workflows that use MultiStageOptSettings.
     """
 
-    mso_mode: Mode
+    mso_mode: Mode = Mode.AUTO
     # Need to use a sentinel object to make both mypy and pydantic happy
     multistage_opt_settings: MultiStageOptSettings = _sentinel_msos  # type: ignore [assignment]
     solvent: Solvent | None = None
@@ -265,3 +265,74 @@ class MultiStageOptMixin(BaseModel):
                 )
 
         return self
+
+
+def build_mso_settings(
+    sp_method: Method,
+    sp_basis_set: str | None,
+    opt_methods: list[Method],
+    opt_basis_sets: list[str | None],
+    mode: Mode = Mode.MANUAL,
+    solvent: Solvent | None = None,
+    use_solvent_for_opt: bool = False,
+    constraints: list[Constraint] | None = None,
+    transition_state: bool = False,
+    frequencies: bool = True,
+) -> MultiStageOptSettings:
+    """
+    Helper function to construct multi-stage opt settings objects manually.
+
+    There's no xTB pre-optimization here - add that yourself!
+
+    :param optimization_settings: list of opt settings to apply successively
+    :param singlepoint_settings: final single point settings
+    :param mode: Mode for settings, defaults to `MANUAL`
+    :param solvent: solvent to use
+    :param use_solvent_for_opt: whether to conduct opts with solvent
+    :param constraints: constraints for optimization
+    :param transition_state: whether this is a transition state
+    :param frequencies: whether to calculate frequencies
+    :returns: the final multistage opt settings
+    """
+    if constraints is None:
+        constraints = []
+
+    opt_settings = OptimizationSettings(constraints=constraints, transition_state=transition_state)
+
+    OPT = [Task.OPTIMIZE if not transition_state else Task.OPTIMIZE_TS]
+
+    def opt(method: Method, basis_set: str | None = None, solvent: Solvent | None = None, freq: bool = False) -> Settings:
+        """Generates optimization settings."""
+        model = "alpb" if method in XTB_METHODS else "cpcm"
+
+        return Settings(
+            method=method,
+            basis_set=basis_set,
+            tasks=OPT + [Task.FREQUENCIES] * freq,
+            solvent_settings=SolventSettings(solvent=solvent, model=model) if (solvent and use_solvent_for_opt) else None,
+            opt_settings=opt_settings,
+        )
+
+    def sp(method: Method, basis_set: str | None = None, solvent: Solvent | None = None) -> Settings:
+        """Generate singlepoint settings."""
+        model = "cpcmx" if method in XTB_METHODS else "cpcm"
+
+        return Settings(
+            method=method,
+            basis_set=basis_set,
+            tasks=[Task.ENERGY],
+            solvent_settings=SolventSettings(solvent=solvent, model=model) if solvent else None,
+        )
+
+    return MultiStageOptSettings(
+        mode=mode,
+        optimization_settings=[
+            opt(method=method, basis_set=basis_set, solvent=solvent, freq=frequencies) for method, basis_set in zip(opt_methods, opt_basis_sets, strict=True)
+        ],
+        singlepoint_settings=sp(method=sp_method, basis_set=sp_basis_set, solvent=solvent),
+        solvent=solvent,
+        xtb_preopt=False,
+        constraints=constraints,
+        transition_state=transition_state,
+        frequencies=frequencies,
+    )

stjames/workflows/redox_potential.py

@@ -1,19 +1,56 @@
-from typing import Any
+from typing import Any, TypeVar
+
+from pydantic import ValidationInfo, field_validator, model_validator
 
 from ..mode import Mode
 from ..solvent import Solvent
 from ..types import UUID
+from .multistage_opt import MultiStageOptMixin
 from .workflow import Workflow
 
+_T = TypeVar("_T")
+
+
+class RedoxPotentialWorkflow(Workflow, MultiStageOptMixin):
+    """
+    Workflow for computing spin states of molecules.
+
+    Uses the modes from MultiStageOptSettings.
+
+    Inherited
+    :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 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
+
+    Overridden:
+    :param mso_mode: Mode for MultiStageOptSettings
+    :param solvent: solvent to use for optimization
+
+    New:
+    :param reduction: whether or not to calculate the reduction half-reaction
+    :param oxidation: whether or not to calculate the oxidation half-reaction
+    :param neutral_molecule: UUID of the calculation for the neutral molecule
+    :param anion_molecule: UUID of the calculation for the anion molecule
+    :param cation_molecule: UUID of the calculation for the cation molecule
+    :param reduction_potential: the final potential, in V
+    :param oxidation_potential: the final potential, in V
+
+    Legacy:
+    :param redox_type: one of "reduction" or "oxidation"
+    :param redox_potential: the corresponding potential, in V
+    """
 
-class RedoxPotentialWorkflow(Workflow):
-    mode: Mode = Mode.RAPID
     solvent: Solvent = Solvent.ACETONITRILE
+
     reduction: bool = True
     oxidation: bool = True
 
     # legacy values - remove in future release!
-    redox_type: UUID | None = None
+    redox_type: str | None = None
     redox_potential: float | None = None
 
     # uuids
@@ -24,6 +61,33 @@ class RedoxPotentialWorkflow(Workflow):
     reduction_potential: float | None = None
     oxidation_potential: float | None = None
 
+    @field_validator("solvent", mode="before")
+    @classmethod
+    def only_mecn_please(cls, val: Solvent | None) -> Solvent:
+        """Only MeCN please!"""
+        if val != Solvent.ACETONITRILE:
+            raise ValueError("Only acetonitrile permitted!")
+
+        return val
+
+    @field_validator("constraints", "transition_state")
+    @classmethod
+    def turned_off(cls, value: _T, info: ValidationInfo) -> _T:
+        if value:
+            raise ValueError(f"{info.field_name} not supported in redox potential workflows.")
+
+        return value
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_mode_and_mso_mode(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """Set the MultiStageOptSettings mode to match current redox potential mode, and select mode if `Auto`."""
+        if ("mode" not in values) or (values["mode"] == Mode.AUTO):
+            values["mode"] = Mode.RAPID
+
+        values["mso_mode"] = values["mode"]
+        return values
+
     def model_post_init(self, __context: Any) -> None:
         """Keep back-compatible with old schema."""
         if self.redox_type == "oxidation":

stjames/workflows/spin_states.py

@@ -51,7 +51,7 @@ class SpinStatesWorkflow(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 optimization
     :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

{stjames-0.0.44.dist-info → stjames-0.0.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stjames
-Version: 0.0.44
+Version: 0.0.45
 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.dist-info → stjames-0.0.45.dist-info}/RECORD

@@ -4,15 +4,15 @@ stjames/atom.py,sha256=w7q-x9xpBw4sJ1WGrWt65WAaStxhz-m7dugXCYEOpq4,2064
 stjames/base.py,sha256=9PvUjBeVSkmA3TaruaB0uvjFMbWYTGKXECISNGAj_AU,1201
 stjames/basis_set.py,sha256=wI3M2q9uPf9jhKpAi4E2DrsyKzloDGLRjAlk7krdYgc,949
 stjames/calculation.py,sha256=O2LwwQ_cOLmDOGXTHA9J71YbUZXigUSbvbLA-fSVm3w,915
-stjames/constraint.py,sha256=IQsQPGbjaoWXZkAOPPBH0_-EGtWwGkkHBhuPg53v5-M,890
-stjames/correction.py,sha256=_pNG3qSylfx0iyUxqwx9HPU0m032YwP6wSPCjbJrD94,358
+stjames/constraint.py,sha256=aD4JkNIyya5uh016R68WLYLd0AK6msgki7Q1kAKGzRs,2203
+stjames/correction.py,sha256=ZVErCcj4TPyZeKrdvXVjHa0tFynsCaoy96QZUVxWFM8,413
 stjames/diis_settings.py,sha256=QHc7L-hktkbOWBYr29byTdqL8lWJzKJiY9XW8ha4Qzo,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=xnfphxyiWZotxQcmgvpFMJDmGEM2B-_5cbPkgYZBIws,1245
+stjames/method.py,sha256=a6QQff-0YsutkOTuOcGrdDW76x9ZexiNLdKzzoE1Vcw,1698
 stjames/mode.py,sha256=xw46Cc7f3eTS8i35qECi-8DocAlANhayK3w4akD4HBU,496
-stjames/molecule.py,sha256=QV_8vscvF48wadWtnt_no5S7j0kHgUbbFr7EnlDnzfk,10558
+stjames/molecule.py,sha256=v8NikFHfwOahXSo4VKGSqeHKI2HIoRdNjGE0GkZgNS4,10554
 stjames/opt_settings.py,sha256=gxXGtjy9l-Q5Wen9eO6T6HHRCuS8rfOofdVQIJj0JcI,550
 stjames/periodic_cell.py,sha256=JDCyynpamggTNi_HnTnnotRbeSMBfYc-srhD-IwUnrg,996
 stjames/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -22,7 +22,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=2FBtEwpaqBIgN7fmVRORJfkv-am0Lssr8e7ho7Fui8w,206
+stjames/types.py,sha256=CPKR0g_kdFejMjGdKBjtuJRQqfmAZ-uIaSuGR1vBzCQ,245
 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
@@ -30,23 +30,25 @@ 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=TQwTrX8hzUKBcCV4C05IvePjnEotsAWTbXv4-b8zDRk,331
+stjames/workflows/__init__.py,sha256=JwcKWrXtrYKJfe6tPbVy6JKSwYxeEaiJWFDL3cVDXf8,363
 stjames/workflows/admet.py,sha256=V8noO0Eb7h2bDFSnj6Pxv4ILm0lGxyVRCi13hE0zmEQ,149
 stjames/workflows/basic_calculation.py,sha256=q48bpab7ZqmRTR4PsGC6bWkuxqkVdJRM8gysevTYXP0,212
-stjames/workflows/bde.py,sha256=c_4gGDFSjHvw4CBW21i6ErSAK2Tpypvld2yair1KYXo,9568
+stjames/workflows/bde.py,sha256=QAcG-ifw_BSyPspOH4EsLNqc3M3b2Xeu4-I2cj-SqoE,9697
 stjames/workflows/conformer.py,sha256=YYwL3l7OaVeea4N9-ihghwa_ieKY6hia9LNbiTraMb0,2732
+stjames/workflows/conformer_search.py,sha256=PjFvotJ3BEMQqsirRxwH7wOIsnV12VuyXQCIyC2NSKE,12485
 stjames/workflows/descriptors.py,sha256=jQ3RuMi7xk799JZ_AL1ARL3yQfWLG03L_VVsK4KIMeY,281
+stjames/workflows/electronic_properties.py,sha256=y4tQl1r6K-Wt_sTjrVyQkq0zukeFQ4KlBrSZgIBZp6Y,3100
 stjames/workflows/fukui.py,sha256=F5tw5jTqBimo_GiXuThhRpoxauZE5YadZjObLFDCba8,348
-stjames/workflows/molecular_dynamics.py,sha256=YsDGkpI_FbB02sVkF1xiUK141cMQaHBjYyvTJarjBaU,1954
-stjames/workflows/multistage_opt.py,sha256=aJGKqsTfVOyZk-dNsM9Z7IEOlpfYw7qvSmxo-u5IeEE,10252
+stjames/workflows/molecular_dynamics.py,sha256=Y3xUJaCO0A4VHvhEHlqJWu2IrEfruCRTqfnC6SdJu18,2194
+stjames/workflows/multistage_opt.py,sha256=gUHtsl3DRvtaZ13_L8CCzAKwridVRnY-0QBNAN0Fq4g,12964
 stjames/workflows/pka.py,sha256=zpR90Yv2L-D56o2mGArM8027DWpnFFnay31UR9Xh5Nc,774
-stjames/workflows/redox_potential.py,sha256=u6QThnqheJp6EDuWiJApJEh-fp0TKGfSyKfa8ykf85g,1211
+stjames/workflows/redox_potential.py,sha256=Jteftsi9SLu2Z4Cq5XpKn9kwn0z3Hkbyfx4Y1p8rCsw,3651
 stjames/workflows/scan.py,sha256=hL4Hco3Ns0dntjh2G2HhhWmED1mbt0gA_hsglPQ5Vjg,814
-stjames/workflows/spin_states.py,sha256=hzxDG8pBlmae8EUEizl0sn6nsXYk4ClmeH-cFZ4bSIc,4606
+stjames/workflows/spin_states.py,sha256=VcCRr7dV-zpazHTkVWb9qds7_4QpTe-Hz_ECdUG9S_Y,4623
 stjames/workflows/tautomer.py,sha256=kZSCHo2Q7LzqtQjF_WyyxjECkndG49T9QOM12hsUkx8,421
 stjames/workflows/workflow.py,sha256=tIu5naADYgYS7kdW8quvGEWHWosBcrIdcD7L86v-uMQ,976
-stjames-0.0.44.dist-info/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
-stjames-0.0.44.dist-info/METADATA,sha256=WxNrF-JxZt7kqljgnu2Ou8i-1lSWefeX3q2GNFDe6Io,1628
-stjames-0.0.44.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-stjames-0.0.44.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
-stjames-0.0.44.dist-info/RECORD,,
+stjames-0.0.45.dist-info/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
+stjames-0.0.45.dist-info/METADATA,sha256=cXN2IrU7jfMFtL93PeemKYzPCGNGZgV7MlQQSOnJL2A,1628
+stjames-0.0.45.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+stjames-0.0.45.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
+stjames-0.0.45.dist-info/RECORD,,

{stjames-0.0.44.dist-info → stjames-0.0.45.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any