stjames 0.0.40__py3-none-any.whl → 0.0.42__py3-none-any.whl

stjames/workflows/multistage_opt.py

@@ -0,0 +1,261 @@
+from typing import Self, Sequence
+
+from pydantic import BaseModel, Field, model_validator
+
+from ..constraint import Constraint
+from ..method import XTB_METHODS, Method
+from ..mode import Mode
+from ..opt_settings import OptimizationSettings
+from ..settings import Settings
+from ..solvent import Solvent, SolventSettings
+from ..task import Task
+from ..types import UUID
+from .workflow import Workflow
+
+
+class MultiStageOptSettings(BaseModel):
+    """
+    Settings for multi-stage optimizations.
+
+    RECKLESS
+        GFN2-xTB//GFN-FF (no pre-opt)
+    RAPID *default
+        r²SCAN-3c//GFN2-xTB with GFN0-xTB pre-opt (off by default)
+    CAREFUL
+        wB97X-3c//B97-3c with GFN2-xTB pre-opt
+    METICULOUS
+        wB97M-D3BJ/def2-TZVPPD//wB97X-3c//B97-3c with GFN2-xTB pre-opt
+
+    Notes:
+    - No solvent in pre-opt
+    - 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 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
+    :param frequencies: whether to calculate frequencies
+
+    >>> msos = MultiStageOptSettings(mode=Mode.RAPID, solvent="water")
+    >>> msos
+    <MultiStageOptSettings RAPID>
+    >>> msos.level_of_theory
+    'r2scan_3c/cpcm(water)//gfn2_xtb/alpb(water)'
+    """
+
+    mode: Mode
+    optimization_settings: Sequence[Settings] = tuple()
+    singlepoint_settings: Settings | None = None
+    solvent: Solvent | None = None
+    xtb_preopt: bool | None = None
+    constraints: Sequence[Constraint] = tuple()
+    transition_state: bool = False
+    frequencies: bool = True
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        """
+        String representation of the settings.
+
+        >>> print(MultiStageOptSettings(mode=Mode.RAPID, solvent="water"))
+        <MultiStageOptSettings RAPID>
+        """
+        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:
+        """
+        Returns the level of theory for the workflow.
+
+        >>> msos = MultiStageOptSettings(mode=Mode.RAPID, solvent="hexane")
+        >>> msos.level_of_theory
+        'r2scan_3c/cpcm(hexane)//gfn2_xtb/alpb(hexane)'
+        """
+        methods = [self.singlepoint_settings] if self.singlepoint_settings else []
+        methods += reversed(self.optimization_settings)
+
+        return "//".join(m.level_of_theory for m in methods)
+
+    @model_validator(mode="after")
+    def set_mode_and_settings(self) -> Self:
+        """Check mode and settings are properly specified, and assign settings based on mode."""
+        opt_or_sp = bool(self.optimization_settings) or bool(self.singlepoint_settings)
+
+        if self.mode == Mode.AUTO:
+            self.mode = Mode.RAPID
+
+        match (self.mode, opt_or_sp):
+            case (Mode.DEBUG, _):
+                raise NotImplementedError("Unsupported mode: DEBUG")
+
+            case (Mode.MANUAL, False):
+                raise ValueError("Must specify at least one of optimization_settings or singlepoint_settings with MANUAL mode")
+            case (Mode.MANUAL, True):
+                pass
+
+            case (mode, True):
+                raise ValueError(f"Cannot specify optimization_settings or singlepoint_settings with {mode=}")
+
+            case (mode, False):
+                self._assign_settings_by_mode(mode)
+
+        return self
+
+    def _assign_settings_by_mode(self, mode: Mode) -> None:
+        """
+        Construct the settings based on the Mode.
+
+        :param mode: Mode to use
+        """
+        opt_settings = OptimizationSettings(constraints=self.constraints, transition_state=self.transition_state)
+
+        # No solvent in pre-opt
+        OPT = [Task.OPTIMIZE if not self.transition_state else Task.OPTIMIZE_TS]
+        gfn0_pre_opt = [Settings(method=Method.GFN0_XTB, tasks=OPT, mode=Mode.RAPID, opt_settings=opt_settings)]
+        gfn2_pre_opt = [Settings(method=Method.GFN2_XTB, tasks=OPT, mode=Mode.RAPID, opt_settings=opt_settings)]
+
+        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 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,
+                solvent_settings=SolventSettings(solvent=solvent, model=model) if solvent else None,
+            )
+
+        match mode:
+            case Mode.RECKLESS:
+                self.xtb_preopt = False
+                self.optimization_settings = [opt(Method.GFN_FF, solvent=self.solvent, 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),
+                ]
+                self.singlepoint_settings = sp(Method.R2SCAN3C, solvent=self.solvent)
+
+            case Mode.CAREFUL:
+                self.xtb_preopt = (self.xtb_preopt is None) or self.xtb_preopt
+                self.optimization_settings = [
+                    *gfn2_pre_opt * self.xtb_preopt,
+                    opt(Method.B973C, solvent=self.solvent, freq=self.frequencies),
+                ]
+                self.singlepoint_settings = sp(Method.WB97X3C, solvent=self.solvent)
+
+            case Mode.METICULOUS:
+                self.xtb_preopt = (self.xtb_preopt is None) or self.xtb_preopt
+                self.optimization_settings = [
+                    *gfn2_pre_opt * self.xtb_preopt,
+                    opt(Method.B973C, solvent=self.solvent),
+                    opt(Method.WB97X3C, solvent=self.solvent, freq=self.frequencies),
+                ]
+                self.singlepoint_settings = sp(Method.WB97MD3BJ, "def2-TZVPPD", solvent=self.solvent)
+
+            case mode:
+                raise NotImplementedError(f"Cannot assign settings for {mode=}")
+
+        assert self.xtb_preopt is not None
+
+
+class MultiStageOptWorkflow(Workflow, MultiStageOptSettings):
+    """
+    Workflow for multi-stage optimizations.
+
+    Inherited
+    :param initial_molecule: Molecule of interest
+    :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 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
+    :param frequencies: whether to calculate frequencies
+
+    Populated while running
+    :param calculations: list of calculation UUIDs
+
+    >>> from stjames.molecule import Atom, Molecule
+    >>> He = Molecule(charge=0, multiplicity=1, atoms=[Atom(atomic_number=2, position=[0, 0, 0])])
+    >>> msow = MultiStageOptWorkflow(initial_molecule=He, mode=Mode.RAPID, solvent="water")
+    >>> msow
+    <MultiStageOptWorkflow RAPID>
+    >>> msow.level_of_theory
+    'r2scan_3c/cpcm(water)//gfn2_xtb/alpb(water)'
+    """
+
+    # Populated while running the workflow
+    calculations: list[UUID | None] = Field(default_factory=list)
+
+
+# the id of a mutable object may change, thus using object()
+_sentinel_msos = object()
+
+
+class MultiStageOptMixin(BaseModel):
+    """
+    Mixin for workflows that use MultiStageOptSettings.
+    """
+
+    mso_mode: Mode
+    # 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
+    xtb_preopt: bool | None = None
+    constraints: Sequence[Constraint] = tuple()
+    transition_state: bool = False
+    frequencies: bool = True
+
+    @model_validator(mode="after")
+    def set_mso_settings(self) -> Self:
+        if self.mso_mode == Mode.AUTO:
+            self.mso_mode = Mode.RAPID
+
+        match self.mso_mode, self.multistage_opt_settings:
+            case (Mode.DEBUG, _):
+                raise NotImplementedError("Unsupported mode: DEBUG")
+
+            case (Mode.MANUAL, msos) if msos is _sentinel_msos:
+                raise ValueError("Must specify multistage_opt_settings with MANUAL mode")
+            case (Mode.MANUAL, _):
+                pass
+
+            case (mso_mode, msos) if msos is not _sentinel_msos:
+                raise ValueError(f"Cannot specify multistage_opt_settings with {mso_mode=}, {msos=}")
+
+            case (mso_mode, _):
+                self.multistage_opt_settings = MultiStageOptSettings(
+                    mode=mso_mode,
+                    solvent=self.solvent,
+                    xtb_preopt=self.xtb_preopt,
+                    constraints=self.constraints,
+                    transition_state=self.transition_state,
+                    frequencies=self.frequencies,
+                )
+
+        return self

stjames/workflows/redox_potential.py

@@ -1,7 +1,8 @@
-from typing import Any, Optional
+from typing import Any
 
 from ..mode import Mode
 from ..solvent import Solvent
+from ..types import UUID
 from .workflow import Workflow
 
 
@@ -12,16 +13,16 @@ class RedoxPotentialWorkflow(Workflow):
     oxidation: bool = True
 
     # legacy values - remove in future release!
-    redox_type: Optional[str] = None
-    redox_potential: Optional[float] = None
+    redox_type: UUID | None = None
+    redox_potential: float | None = None
 
     # uuids
-    neutral_molecule: Optional[str] = None
-    anion_molecule: Optional[str] = None
-    cation_molecule: Optional[str] = None
+    neutral_molecule: UUID | None = None
+    anion_molecule: UUID | None = None
+    cation_molecule: UUID | None = None
 
-    reduction_potential: Optional[float] = None
-    oxidation_potential: Optional[float] = None
+    reduction_potential: float | None = None
+    oxidation_potential: float | None = None
 
     def model_post_init(self, __context: Any) -> None:
         """Keep back-compatible with old schema."""

stjames/workflows/scan.py

@@ -1,18 +1,18 @@
-from typing import Optional
-
 import numpy as np
+from numpy.typing import NDArray
 
 from ..base import Base
 from ..molecule import Molecule
 from ..settings import Settings
+from ..types import UUID
 from .workflow import Workflow
 
 
 class ScanPoint(Base):
     index: int
     molecule: Molecule
-    energy: Optional[float] = None
-    uuid: Optional[str] = None
+    energy: float | None = None
+    uuid: UUID | None = None
 
 
 class ScanSettings(Base):
@@ -22,7 +22,7 @@ class ScanSettings(Base):
     stop: float
     num: int
 
-    def vals(self) -> np.ndarray:
+    def vals(self) -> NDArray[np.float64]:
         return np.linspace(self.start, self.stop, self.num)
 
     class Config:
@@ -35,4 +35,4 @@ class ScanWorkflow(Workflow):
     calc_engine: str
 
     # uuids of scan points
-    scan_points: list[str] = []
+    scan_points: list[UUID | None] = []

stjames/workflows/spin_states.py

@@ -0,0 +1,144 @@
+from typing import Any
+
+from pydantic import BaseModel, Field, PositiveInt, field_validator, model_validator
+
+from ..mode import Mode
+from ..types import UUID
+from .multistage_opt import MultiStageOptMixin
+from .workflow import Workflow
+
+
+class SpinState(BaseModel):
+    """
+    The result of a SpinState calculation.
+
+    :param multiplicity: multiplicity of the SpinState
+    :param energy: energy of the optimized Molecule
+    :param calculation: the UUIDs of the Calculations that produced this SpinState
+
+    >>> from stjames.molecule import Atom, Molecule
+    >>> He = Molecule(charge=0, multiplicity=1, atoms=[Atom(atomic_number=2, position=[0, 0, 0])])
+    >>> SpinState(multiplicity=3, energy=-13.4291, calculation=['8a031a27-30d2-4ac7-8ade-efae9e9fc94a'])
+    <SpinState 3 -13.429>
+    """
+
+    multiplicity: PositiveInt
+    energy: float
+    calculation: list[UUID | None]
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.multiplicity} {self.energy:.3f}>"
+
+
+_sentinel_mso_mode = object()
+
+
+class SpinStatesWorkflow(Workflow, MultiStageOptMixin):
+    """
+    Workflow for computing spin states of molecules.
+
+    Uses the modes from MultiStageOptSettings.
+
+    Influenced by:
+    [Performance of Quantum Chemistry Methods for Benchmark Set of Spin–State
+    Energetics Derived from Experimental Data of 17 Transition Metal Complexes
+    (SSE17)](https://chemrxiv.org/engage/chemrxiv/article-details/66a8b15cc9c6a5c07a792487)
+
+    Inherited
+    :param initial_molecule: Molecule of interest
+    :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
+
+    Overridden:
+    :param mso_mode: Mode for MultiStageOptSettings
+
+    New:
+    :param mode: Mode for workflow
+    :param states: multiplicities of the spin state targetted
+    :param spin_states: resulting spin states data
+
+
+    >>> from stjames.molecule import Atom, Molecule
+    >>> He = Molecule(charge=0, multiplicity=1, atoms=[Atom(atomic_number=2, position=[0, 0, 0])])
+    >>> ss = SpinStatesWorkflow(initial_molecule=He, states=[1, 3, 5], mode=Mode.RAPID, solvent="water")
+    >>> str(ss)
+    '<SpinStatesWorkflow [1, 3, 5] RAPID>'
+    """
+
+    mode: Mode
+    mso_mode: Mode = _sentinel_mso_mode  # type: ignore [assignment]
+    states: list[PositiveInt]
+
+    # Results
+    spin_states: list[SpinState] = Field(default_factory=list)
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        if self.mode != Mode.MANUAL:
+            return f"<{type(self).__name__} {self.states} {self.mode.name}>"
+
+        return f"<{type(self).__name__} {self.states} {self.level_of_theory}>"
+
+    def __len__(self) -> int:
+        return len(self.states)
+
+    @property
+    def level_of_theory(self) -> str:
+        return self.multistage_opt_settings.level_of_theory
+
+    @field_validator("states")
+    @classmethod
+    def validate_states(cls, states: list[PositiveInt]) -> list[PositiveInt]:
+        """Confirm that all spin states are valid."""
+        if not states:
+            raise ValueError("Expected at least one spin state.")
+
+        if any((states[0] - mult) % 2 for mult in states):
+            raise ValueError(f"Inconsistent multiplicities found: {states}")
+
+        return states
+
+    def str_results(self) -> str:
+        return "SpinStatesResults\n" + "\n".join(f"  {ss.multiplicity}: {ss.energy:>5.2f}" for ss in self.spin_states)
+
+    @property
+    def energies(self) -> list[float]:
+        return [ss.energy for ss in self.spin_states]
+
+    @model_validator(mode="before")
+    @classmethod
+    def set_mso_mode(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """Set the MultiStageOptSettings mode to match current SpinStates mode."""
+        values["mso_mode"] = values["mode"]
+        return values
+
+    @field_validator("mode")
+    @classmethod
+    def set_mode_auto(cls, mode: Mode) -> Mode:
+        if mode == Mode.AUTO:
+            return Mode.RAPID
+
+        return mode
+
+    @field_validator("spin_states")
+    @classmethod
+    def validate_spin_states(cls, spin_states: list[SpinState]) -> list[SpinState]:
+        """Ensure that all spin states have consistent results."""
+        mults = [ss.multiplicity for ss in spin_states]
+
+        if len(mults) != len(set(mults)):
+            raise ValueError(f"Duplicate multiplicities found: {mults}")
+
+        if any((mults[0] - mult) % 2 for mult in mults[1:]):
+            raise ValueError(f"Inconsistent multiplicities found: {mults}")
+
+        return spin_states

stjames/workflows/workflow.py

@@ -1,6 +1,10 @@
+from pydantic import BaseModel, ConfigDict
+
 from ..base import Base
 from ..message import Message
+from ..mode import Mode
 from ..molecule import Molecule
+from ..types import UUID
 
 
 class Workflow(Base):
@@ -13,4 +17,30 @@ class Workflow(Base):
 class DBCalculation(Base):
     """Encodes a calculation that's in the database. This isn't terribly useful by itself."""
 
-    uuid: str
+    uuid: UUID
+
+
+class WorkflowInput(BaseModel):
+    """
+    Input for a workflow.
+
+    :param initial_molecule: Molecule of interest
+    :param mode: Mode for workflow
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    initial_molecule: Molecule
+    mode: Mode
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.mode.name}>"
+
+
+class WorkflowResults(BaseModel):
+    """Results of a workflow."""
+
+    model_config = ConfigDict(extra="forbid", frozen=True)

{stjames-0.0.40.dist-info → stjames-0.0.42.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: stjames
-Version: 0.0.40
+Version: 0.0.42
 Summary: standardized JSON atom/molecule encoding scheme
 Author-email: Corin Wagen <corin@rowansci.com>
 Project-URL: Homepage, https://github.com/rowansci/stjames
 Project-URL: Bug Tracker, https://github.com/rowansci/stjames/issues
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pydantic >=2.4
@@ -27,7 +27,7 @@ This is not intended to be run as a standalone library: it's basically just a bi
 
 ## Installation
 
-To install, ensure you have Python 3.8 or newer. Then run:
+To install, ensure you have Python 3.11 or newer. Then run:
 
 ```
 pip install stjames

stjames-0.0.42.dist-info/RECORD

@@ -0,0 +1,52 @@
+stjames/__init__.py,sha256=LkWCylP4VeXyQL0iu5w6yeYK1UHjcUH55hwWXTy4mQQ,576
+stjames/_deprecated_solvent_settings.py,sha256=gj5j9p3zakIwSTK5_ndqBXJx--IzjZNxZ75z-wipLOo,450
+stjames/atom.py,sha256=2NZ-tyWk6uPrn_rsANFFultNHS0CvgYYXwj8rud991M,2056
+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/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/mode.py,sha256=xw46Cc7f3eTS8i35qECi-8DocAlANhayK3w4akD4HBU,496
+stjames/molecule.py,sha256=XJdfEJndl4DqY_mg5scWH9xWQU8gNcXN74Qb4n2TN1c,6798
+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
+stjames/scf_settings.py,sha256=xMMCQ0hVB4nNFSiWesNQZUa_aLsozSZGYWweAPPDGBg,2356
+stjames/settings.py,sha256=-MSVrfRcBz6O7aRZA-xTtEfJHRJ8BRxc6Bg9wad2DSY,8786
+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/data/__init__.py,sha256=O59Ksp7AIqwOELCWymfCx7YeBzwNOGCMlGQi7tNLqiE,24
+stjames/data/bragg_radii.json,sha256=hhbn-xyZNSdmnULIjN2Cvq-_BGIZIqG243Ls_mey61w,1350
+stjames/data/elements.py,sha256=9BW01LZlyJ0H5s7Q26vUmjZIST41fwOYYrGvmPd7q0w,858
+stjames/data/isotopes.json,sha256=5ba8QnLrHD_Ypv2xekv2cIRwYrX3MQ19-1FOFtt0RuU,8357
+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/admet.py,sha256=V8noO0Eb7h2bDFSnj6Pxv4ILm0lGxyVRCi13hE0zmEQ,149
+stjames/workflows/basic_calculation.py,sha256=q48bpab7ZqmRTR4PsGC6bWkuxqkVdJRM8gysevTYXP0,212
+stjames/workflows/bde.py,sha256=rboqtrV1DNwq7MKPht9g5d7ahHxaqGN-PvXlTjGor4M,9831
+stjames/workflows/conformer.py,sha256=YYwL3l7OaVeea4N9-ihghwa_ieKY6hia9LNbiTraMb0,2732
+stjames/workflows/descriptors.py,sha256=jQ3RuMi7xk799JZ_AL1ARL3yQfWLG03L_VVsK4KIMeY,281
+stjames/workflows/fukui.py,sha256=F5tw5jTqBimo_GiXuThhRpoxauZE5YadZjObLFDCba8,348
+stjames/workflows/molecular_dynamics.py,sha256=ImZN9G1xolkUSXyv0d_KKPtCIPG9uXdkVyJuFdtOToU,1917
+stjames/workflows/multistage_opt.py,sha256=YL-lbpJs8AB5vOERonb7-Q69SIM4feuB9mUtbepYIHA,10040
+stjames/workflows/pka.py,sha256=zpR90Yv2L-D56o2mGArM8027DWpnFFnay31UR9Xh5Nc,774
+stjames/workflows/redox_potential.py,sha256=u6QThnqheJp6EDuWiJApJEh-fp0TKGfSyKfa8ykf85g,1211
+stjames/workflows/scan.py,sha256=hL4Hco3Ns0dntjh2G2HhhWmED1mbt0gA_hsglPQ5Vjg,814
+stjames/workflows/spin_states.py,sha256=hzGbYfG4KGYYQPV4cF0ufCndDMoIVnZt2ZZt7LqvJgc,4854
+stjames/workflows/tautomer.py,sha256=kZSCHo2Q7LzqtQjF_WyyxjECkndG49T9QOM12hsUkx8,421
+stjames/workflows/workflow.py,sha256=t5Yz-d5WgSQEiHbiZfc4NQ653mEnydiGZ-lEkkPYAKw,994
+stjames-0.0.42.dist-info/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
+stjames-0.0.42.dist-info/METADATA,sha256=mIKojGiwySNE8F0-7hulBNJv2WFORfn08rwCUghPbWM,1628
+stjames-0.0.42.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+stjames-0.0.42.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
+stjames-0.0.42.dist-info/RECORD,,

{stjames-0.0.40.dist-info → stjames-0.0.42.dist-info}/WHEEL

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

stjames-0.0.40.dist-info/RECORD

@@ -1,36 +0,0 @@
-stjames/__init__.py,sha256=RJ1b132RSXVbQfptduVM1ZSQrnSTsg0a-VfgBwQn9zo,506
-stjames/_deprecated_solvent_settings.py,sha256=gj5j9p3zakIwSTK5_ndqBXJx--IzjZNxZ75z-wipLOo,450
-stjames/base.py,sha256=R49yN4UoiOSjZEkadbMLqLLVNYmysXE4VvCU5JHTCNg,1190
-stjames/basis_set.py,sha256=Fi6vJx-ni2aOozFYH2hrSlc9lL01XzPO4zO6onJliuE,1035
-stjames/calculation.py,sha256=0eCZ59lqmnI_QxEdMp7esrTeutNyO_pIFrZQf_FncSo,848
-stjames/constraint.py,sha256=gkp0y0yQPeii8jdBNllZ9JS8t0o2bkEVTFAkyhShmWk,329
-stjames/correction.py,sha256=_pNG3qSylfx0iyUxqwx9HPU0m032YwP6wSPCjbJrD94,358
-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=iThn9tkkM0x0uX95o3Tcz3QQtad47UYGDL76hW3ySaM,787
-stjames/mode.py,sha256=xw46Cc7f3eTS8i35qECi-8DocAlANhayK3w4akD4HBU,496
-stjames/molecule.py,sha256=G78Bm88r8w-4cx_AOUyxLrn_gIt-TdeoYeBoiociqX8,3032
-stjames/opt_settings.py,sha256=5nTGih8KZ3x_yGfPL7pdGdsuOpCIfuJUrKoSK5YSDJg,458
-stjames/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stjames/scf_settings.py,sha256=xMMCQ0hVB4nNFSiWesNQZUa_aLsozSZGYWweAPPDGBg,2356
-stjames/settings.py,sha256=mn9TY2y2Juqou-bfIkXFWM_pbs_90-MgYYzAnWXCwVQ,8660
-stjames/solvent.py,sha256=0Kb2O3kTXMbcTH2br9bg7vtgG-Q7uRzhcMKSdUktVNo,1140
-stjames/status.py,sha256=wTKNcNxStoEHrxxgr_zTyN90NITa3rxMQZzOgrCifEw,332
-stjames/task.py,sha256=TTl-iTdvDNCZTdPsyS6bYmxzY0ez9PgYlL62fztayXQ,307
-stjames/thermochem_settings.py,sha256=ZTLz31v8Ltutde5Nfm0vH5YahWjcfFWfr_R856KffxE,517
-stjames/workflows/__init__.py,sha256=sy9J04mCJpyVGcG4DecCi6pncwbZVvybI7sJKzavjgo,167
-stjames/workflows/conformer.py,sha256=YYwL3l7OaVeea4N9-ihghwa_ieKY6hia9LNbiTraMb0,2732
-stjames/workflows/descriptors.py,sha256=Jqx_4u_ZhdFJrT-ITU6zlFY0n8llh6zhzIhM38e8NCs,255
-stjames/workflows/fukui.py,sha256=FAabgLi_ig6Zp_jiTkuveP0wAObwv68liuumr85rb0g,366
-stjames/workflows/pka.py,sha256=zpR90Yv2L-D56o2mGArM8027DWpnFFnay31UR9Xh5Nc,774
-stjames/workflows/redox_potential.py,sha256=iPkFt1Dj1sUywS9pLSEBVpCjHZcEwUESluY0ggLii8A,1213
-stjames/workflows/scan.py,sha256=d1ca1uk1nxdzlSwqMLZ0W1_DHyrQMnHJmvPfziCS0SA,773
-stjames/workflows/tautomer.py,sha256=kZSCHo2Q7LzqtQjF_WyyxjECkndG49T9QOM12hsUkx8,421
-stjames/workflows/workflow.py,sha256=6hFe5PZejJu6bZ3yTkoJ9-xQMBn_-8tUsbk4FUZxog0,367
-stjames-0.0.40.dist-info/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
-stjames-0.0.40.dist-info/METADATA,sha256=GeuHmCFTQwu5cq521KVGYIdQBKmyOuBwonQ19a3ShO0,1626
-stjames-0.0.40.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-stjames-0.0.40.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
-stjames-0.0.40.dist-info/RECORD,,