stjames 0.0.98__py3-none-any.whl → 0.0.101__py3-none-any.whl

stjames/engine.py

@@ -1,7 +1,7 @@
 from .base import LowercaseStrEnum
 
 
-class Mode(LowercaseStrEnum):
+class Engine(LowercaseStrEnum):
     AIMNET2 = "aimnet2"
     MACE = "mace"
     OCP24 = "ocp24"

stjames/method.py

@@ -1,6 +1,7 @@
 from typing import Literal
 
 from .base import LowercaseStrEnum
+from .engine import Engine
 
 
 class Method(LowercaseStrEnum):
@@ -55,48 +56,42 @@ class Method(LowercaseStrEnum):
     EGRET_1E = "egret_1e"
     EGRET_1T = "egret_1t"
 
-    def default_engine(self, *, is_periodic: bool = False) -> str:
+    def default_engine(self, *, is_periodic: bool = False) -> Engine:
         """
-        Return the canonical engine name for this quantum-chemistry method.
+        Return the canonical Engine for this quantum-chemistry method.
 
         :param bool is_periodic:
             If ``True`` **and** the method is in the XTB family, return
             ``"tblite"`` (periodic-capable backend) instead of ``"xtb"``.
-        :returns: Lower-case engine identifier (e.g. ``"psi4"``, ``"mace"``).
-
-        **Examples**
-
-        .. code-block:: python
-
-           Method.MACE_MP_0B2_L.default_engine()
-           # 'mace'
-
-           Method.GFN2_XTB.default_engine()
-           # 'xtb'
-
-           Method.GFN2_XTB.default_engine(is_periodic=True)
-           # 'tblite'
+        :returns: lower-case engine identifier (e.g. ``"psi4"``, ``"mace"``).
+
+        >>> Method.MACE_MP_0B2_L.default_engine().value
+        'mace'
+        >>> Method.GFN2_XTB.default_engine().value
+        'xtb'
+        >>> Method.GFN2_XTB.default_engine(is_periodic=True).value
+        'tblite'
         """
         match self:
             case Method.AIMNET2_WB97MD3:
-                return "aimnet2"
+                return Engine.AIMNET2
             case Method.MACE_MP_0B2_L:
-                return "mace"
+                return Engine.MACE
             case Method.OCP24_S | Method.OCP24_L:
-                return "ocp24"
+                return Engine.OCP24
             case Method.OMOL25_CONSERVING_S | Method.UMA_M_OMOL | Method.UMA_S_OMOL:
-                return "omol25"
+                return Engine.OMOL25
             case Method.ORB_V3_CONSERVATIVE_INF_OMAT:
-                return "orb"
-            case _ if self in XTB_METHODS:
-                return "tblite" if is_periodic else "xtb"
+                return Engine.ORB
+            case method if method in XTB_METHODS:
+                return Engine.TBLITE if is_periodic else Engine.XTB
             case Method.OFF_SAGE_2_2_1:
-                return "openff"
+                return Engine.OPENFF
             case Method.EGRET_1 | Method.EGRET_1E | Method.EGRET_1T:
-                return "egret"
+                return Engine.EGRET
             case _:
                 # All remaining methods (HF, DFT, composite, etc.) fall back to Psi4
-                return "psi4"
+                return Engine.PSI4
 
 
 PrepackagedNNPMethod = Literal[

stjames/molecule.py

@@ -157,12 +157,20 @@ class Molecule(Base):
             return None
         return self.energy + self.thermal_enthalpy_corr
 
+    @property
+    def enthalpy(self) -> Optional[float]:
+        return self.sum_energy_enthalpy
+
     @property
     def sum_energy_free_energy(self) -> Optional[float]:
         if (self.energy is None) or (self.thermal_free_energy_corr is None):
             return None
         return self.energy + self.thermal_free_energy_corr
 
+    @property
+    def gibbs_free_energy(self) -> Optional[float]:
+        return self.sum_energy_free_energy
+
     @pydantic.model_validator(mode="after")
     def check_electron_sanity(self) -> Self:
         num_electrons = sum(self.atomic_numbers) - self.charge

stjames/optimization/freezing_string_method.py

@@ -0,0 +1,56 @@
+"""Settings for the Freezing String Method (FSM)."""
+
+from typing import Annotated, Self
+
+from pydantic import AfterValidator, BaseModel, PositiveFloat, PositiveInt, model_validator
+
+from ..base import LowercaseStrEnum, round_float
+
+
+class FSMOptimizationCoordinates(LowercaseStrEnum):
+    """Coordinate systems for FSM optimization step."""
+
+    CARTESIAN = "cartesian"
+    REDUNDANT_INTERNAL_COORDINATES = "redundant_internal_coordinates"
+
+
+class FSMInterpolation(LowercaseStrEnum):
+    """Methods for FSM interpolation step."""
+
+    CARTESIAN = "cartesian"
+    LINEAR_SYNCHRONOUS_TRANSIT = "linear_synchronous_transit"
+    REDUNDANT_INTERNAL_COORDINATES = "redundant_internal_coordinates"
+
+
+class FSMSettings(BaseModel):
+    """
+    Settings for the Freezing String Method (FSM) TS search.
+
+    :param opt_coords: coordinate system to use for optimization
+    :param interpolation_method: method to use for interpolation between nodes
+    :param min_num_nodes: minimum number of nodes to use in the string
+    :param num_interpolation_points: number of interpolation points to use between end nodes
+    :param max_optimizer_iterations: maximum number of optimizer iterations to perform  (scipy.minimize maxiter)
+    :param max_line_search_steps: maximum number of line search steps to perform (scipy.minimize maxls)
+    :param max_displacement: maximum displacement for a single coordinate (Å for distances, internally converted for angles)
+    """
+
+    optimization_coordinates: FSMOptimizationCoordinates = FSMOptimizationCoordinates.CARTESIAN
+    interpolation_method: FSMInterpolation = FSMInterpolation.REDUNDANT_INTERNAL_COORDINATES
+
+    min_num_nodes: PositiveInt = 18
+    num_interpolation_points: PositiveInt = 100
+
+    max_optimizer_iterations: PositiveInt = 3
+    max_line_search_steps: PositiveInt = 2
+    max_displacement: Annotated[PositiveFloat, AfterValidator(round_float(3))] = 0.3
+
+    @model_validator(mode="after")
+    def sanity_check(self) -> Self:
+        """Sanity check for settings."""
+        if self.min_num_nodes < 5:
+            raise ValueError("Must have at least 5 nodes for the Freezing String Method.")
+        if self.max_displacement < 0.001:
+            raise ValueError("Maximum displacement must be at least 0.001 Å.")
+
+        return self

stjames/workflows/__init__.py

@@ -9,6 +9,7 @@ from .conformer import *
 from .conformer_search import *
 from .descriptors import *
 from .docking import *
+from .double_ended_ts_search import DoubleEndedTSSearchWorkflow
 from .electronic_properties import *
 from .fukui import *
 from .hydrogen_bond_basicity import *
@@ -36,6 +37,7 @@ WORKFLOW_NAME = Literal[
     "conformer_search",
     "descriptors",
     "docking",
+    "double_ended_ts_search",
     "electronic_properties",
     "fukui",
     "hydrogen_bond_basicity",
@@ -63,6 +65,7 @@ WORKFLOW_MAPPING: dict[WORKFLOW_NAME, Workflow] = {
     "conformer_search": ConformerSearchWorkflow,  # type: ignore [dict-item]
     "descriptors": DescriptorsWorkflow,  # type: ignore [dict-item]
     "docking": DockingWorkflow,  # type: ignore [dict-item]
+    "double_ended_ts_search": DoubleEndedTSSearchWorkflow,  # type: ignore [dict-item]
     "electronic_properties": ElectronicPropertiesWorkflow,  # type: ignore [dict-item]
     "fukui": FukuiIndexWorkflow,  # type: ignore [dict-item]
     "hydrogen_bond_basicity": HydrogenBondBasicityWorkflow,  # type: ignore [dict-item]

stjames/workflows/basic_calculation.py

@@ -1,5 +1,10 @@
 """Basic calculation workflow."""
 
+from typing import Self
+
+from pydantic import model_validator
+
+from ..engine import Engine
 from ..settings import Settings
 from ..types import UUID
 from .workflow import MoleculeWorkflow
@@ -20,5 +25,12 @@ class BasicCalculationWorkflow(MoleculeWorkflow):
     """
 
     settings: Settings
-    engine: str
+    engine: Engine = None  # type: ignore [assignment]
     calculation_uuid: UUID | None = None
+
+    @model_validator(mode="after")
+    def set_engine(self) -> Self:
+        """Set the calculation engine."""
+        self.engine = self.engine or self.settings.method.default_engine()
+
+        return self

stjames/workflows/docking.py

@@ -58,11 +58,10 @@ class DockingWorkflow(MoleculeWorkflow):
     :param mode: Mode for workflow (currently unused)
 
     New:
-    :param docking_engine: which docking method to use
     :param do_csearch: whether to csearch starting structures
-    :param csearch_settings: settings for initial conformer search.
+    :param conformer_gen_settings: settings for initial conformer search.
     :param do_optimization: whether to optimize starting structures
-    :param opt_settings: settings for conformer optimization.
+    :param optimization_settings: settings for conformer optimization.
     :param do_pose_refinement: whether to optimize non-rotatable bonds in output poses
     :param target: PDB of the protein.
     :param target_uuid: UUID of the protein.

stjames/workflows/double_ended_ts_search.py

@@ -0,0 +1,77 @@
+"""Double ended transition-state-search workflow."""
+
+from typing import Annotated, Self
+
+from pydantic import AfterValidator, PositiveFloat, model_validator
+
+from ..molecule import Molecule
+from ..optimization.freezing_string_method import FSMSettings
+from ..settings import Settings
+from ..types import UUID, round_list
+from .workflow import Workflow
+
+
+class DoubleEndedTSSearchWorkflow(Workflow):
+    """
+    Settings for running a double-ended-transition-state-search Workflow.
+
+    # Inputs
+    :param reactant: reactant Molecule
+    :param product: product Molecule
+    :param calculation_settings: Settings for the calculations
+    :param search_settings: Settings for the search
+    :param optimize_inputs: Whether to optimize the input reactant and product
+    :param optimize_ts: Whether to optimize the guess transition state
+
+    # Results
+    :param forward_string_distances: distances along the string
+    :param backward_string_distances: distances along the backward string (starting from the end of the forward string)
+    :param forward_calculation_uuids: UUIDs of the calculations for the forward string nodes
+    :param backward_calculation_uuids: UUIDs of the calculations for the backward string nodes
+    :param ts_guess_calculation_uuid: UUID of the calculation for the guess (or optimized) transition state
+    """
+
+    reactant: Molecule
+    product: Molecule
+
+    calculation_settings: Settings
+    search_settings: FSMSettings
+    optimize_inputs: bool = False
+    optimize_ts: bool = True
+
+    # Results
+    forward_string_distances: Annotated[list[PositiveFloat], AfterValidator(round_list(5))] = []
+    backward_string_distances: Annotated[list[PositiveFloat], AfterValidator(round_list(5))] = []
+
+    forward_calculation_uuids: list[UUID | None] = []
+    backward_calculation_uuids: list[UUID | None] = []
+
+    ts_guess_calculation_uuid: UUID | None = None
+
+    @model_validator(mode="after")
+    def validate_input_molecules(self) -> Self:
+        """Validate that reactant and product are compatible."""
+
+        if self.reactant.charge != self.product.charge:
+            raise ValueError("Reactant and product must have the same charge.")
+        if self.reactant.multiplicity != self.product.multiplicity:
+            raise ValueError("Reactant and product must have the same multiplicity.")
+
+        if len(self.reactant) != len(self.product):
+            raise ValueError("Reactant and product must have the same number of atoms.")
+
+        for r_atom, p_atom in zip(self.reactant.atoms, self.product.atoms, strict=True):
+            if r_atom.atomic_number != p_atom.atomic_number:
+                raise ValueError("Reactant and product must have the same atom ordering.")
+
+        return self
+
+    @property
+    def path_uuids(self) -> list[UUID | None]:
+        """Return the path from reactant to product."""
+        return self.forward_calculation_uuids + self.backward_calculation_uuids
+
+    @property
+    def distances(self) -> list[float]:
+        """Return the path from reactant to product."""
+        return self.forward_string_distances + self.backward_string_distances[::-1]

stjames/workflows/fukui.py

@@ -1,10 +1,13 @@
 """Fukui index workflow."""
 
-from typing import Annotated
+from typing import Annotated, Self
 
-from pydantic import AfterValidator
+from pydantic import AfterValidator, model_validator
+
+from stjames.method import Method
 
 from ..base import round_optional_float
+from ..engine import Engine
 from ..settings import Settings
 from ..types import UUID, FloatPerAtom, round_optional_float_per_atom
 from .workflow import MoleculeWorkflow
@@ -20,9 +23,9 @@ class FukuiIndexWorkflow(MoleculeWorkflow):
 
     Settings:
     :param opt_settings: if given, the settings for optimization. if none, no optimization will be conducted.
-    :param opt_engine: the engine for optimization
+    :param opt_engine: the engine for optimization [uses opt_settings.method.default_engine if not set]
     :param fukui_settings: the settings for Fukui index calculations.
-    :param fukui_engine: the engine for Fukui index calculations
+    :param fukui_engine: the engine for Fukui index calculations [uses fukui_settings.method.default_engine if not set]
 
     Results:
     :param optimization: UUID of optimization
@@ -33,10 +36,10 @@ class FukuiIndexWorkflow(MoleculeWorkflow):
     """
 
     opt_settings: Settings | None = None
-    opt_engine: str | None = None
+    opt_engine: Engine | None = None
 
-    fukui_settings: Settings = Settings(method="gfn1_xtb")
-    fukui_engine: str | None = None
+    fukui_settings: Settings = Settings(method=Method.GFN1_XTB)
+    fukui_engine: Engine = None  # type: ignore [assignment]
 
     optimization: UUID | None = None
 
@@ -44,3 +47,12 @@ class FukuiIndexWorkflow(MoleculeWorkflow):
     fukui_positive: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None
     fukui_negative: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None
     fukui_zero: Annotated[FloatPerAtom | None, AfterValidator(round_optional_float_per_atom(6))] = None
+
+    @model_validator(mode="after")
+    def set_engines(self) -> Self:
+        """Set the engines for optimization and Fukui index calculations."""
+        if self.opt_settings is not None and self.opt_engine is None:
+            self.opt_engine = self.opt_settings.method.default_engine()
+        self.fukui_engine = self.fukui_engine or self.fukui_settings.method.default_engine()
+
+        return self

stjames/workflows/molecular_dynamics.py

@@ -6,6 +6,7 @@ from pydantic import PositiveFloat, PositiveInt, computed_field, model_validator
 
 from ..base import Base, LowercaseStrEnum
 from ..constraint import PairwiseHarmonicConstraint, SphericalHarmonicConstraint
+from ..engine import Engine
 from ..settings import Settings
 from ..types import UUID
 from .workflow import MoleculeWorkflow
@@ -87,7 +88,7 @@ class MolecularDynamicsWorkflow(MoleculeWorkflow):
     New:
     :param settings: settings for the molecular dynamics simulation
     :param calc_settings: settings for the gradient calculation
-    :param calc_engine: engine to use for the gradient calculation
+    :param calc_engine: engine to use for the gradient calculation [uses calc_settings.method.default_engine() if not set]
 
     Results:
     :param frames: Frames from the MD
@@ -95,6 +96,13 @@ class MolecularDynamicsWorkflow(MoleculeWorkflow):
 
     settings: MolecularDynamicsSettings
     calc_settings: Settings
-    calc_engine: str | None = None
+    calc_engine: Engine = None  # type: ignore[assignment]
 
     frames: list[Frame] = []
+
+    @model_validator(mode="after")
+    def validate_calc_engine(self) -> Self:
+        """Ensure that the calc_engine is set."""
+        self.calc_engine = self.calc_engine or self.calc_settings.method.default_engine()
+
+        return self

stjames/workflows/nmr.py

@@ -29,7 +29,7 @@ class NMRPeak(Base):
 
     nucleus: int
     shift: Annotated[float, AfterValidator(round_float(3))]
-    atom_indices: set[int]
+    atom_indices: list[int]
 
 
 class NMRSpectroscopyWorkflow(MoleculeWorkflow):
@@ -68,6 +68,6 @@ class NMRSpectroscopyWorkflow(MoleculeWorkflow):
     boltzmann_weights: Annotated[list[float], AfterValidator(round_list(3))] = []
     per_conformer_chemical_shifts: list[Annotated[list[float | None], AfterValidator(round_optional_list(3))]] = []
     chemical_shifts: Annotated[list[float | None], AfterValidator(round_optional_list(3))] = []
-    symmetry_equivalent_nuclei: list[set[int]] = []
+    symmetry_equivalent_nuclei: list[list[int]] = []
 
     predicted_peaks: dict[int, list[NMRPeak]] = {}

{stjames-0.0.98.dist-info → stjames-0.0.101.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stjames
-Version: 0.0.98
+Version: 0.0.101
 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.98.dist-info → stjames-0.0.101.dist-info}/RECORD

@@ -7,11 +7,11 @@ stjames/calculation.py,sha256=O2LwwQ_cOLmDOGXTHA9J71YbUZXigUSbvbLA-fSVm3w,915
 stjames/compute_settings.py,sha256=wuYE6W4WqP3oFHwAeEp7XQ0oMz_MNLucWgrsuJ4kEFQ,268
 stjames/constraint.py,sha256=B6oV0rYjmAWr8gpi5f03gRy_uuqjUURVDVwoez5Cfbg,2442
 stjames/correction.py,sha256=ZVErCcj4TPyZeKrdvXVjHa0tFynsCaoy96QZUVxWFM8,413
-stjames/engine.py,sha256=wVItZQSIeR3ap6EZG3kOw0xCZztZm-6KKFrX84ZyFsE,313
+stjames/engine.py,sha256=4Vt1uF1jNGPj-06F2I73oU5RoH1MlNOlDRSNkWN91NE,315
 stjames/message.py,sha256=Rq6QqmHZKecWxYH8fVyXmuoCCPZv8YinvgykSeorXSU,216
-stjames/method.py,sha256=8Cj0JYGMEaS_Cetfz8Wcu6-BZAv1SejRSagMgkKaXs0,4469
+stjames/method.py,sha256=gZbrHAivm2OXCbF3_6swei1LG6YQ7Uo1EY7aN0x3XHs,4501
 stjames/mode.py,sha256=xw46Cc7f3eTS8i35qECi-8DocAlANhayK3w4akD4HBU,496
-stjames/molecule.py,sha256=l4S6prH1xflnZtbwidSF2THsiHaSJtRiy1rmUbH366Q,20631
+stjames/molecule.py,sha256=4Tsa_gRC4C-qGPop24jRIs2q07r0LGbSRb-ApOaZa5c,20839
 stjames/opt_settings.py,sha256=LEwGXUEKq5TfU5rr60Z4QQBhCqiw1Ch5w0M_lXawWo8,642
 stjames/pdb.py,sha256=6ayVUUdTufkXs_nfpRQuT1yGvymuyICB4L5Wh55OsaA,26507
 stjames/periodic_cell.py,sha256=eV_mArsY_MPEFSrFEsTC-CyCc6V8ITAXdk7yhjjNI7M,1080
@@ -35,23 +35,26 @@ 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=wGTCSEvGmLVG-dnkylVsKq7_27n8gQlFfsJiX9RN33w,2890
+stjames/optimization/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stjames/optimization/freezing_string_method.py,sha256=eEQBqbYHgJH9gVRLDIFtGuPcsHHMLAAt1hF3jtq70lo,2285
+stjames/workflows/__init__.py,sha256=-HhT_DJeYCzTO-FeM-wabFyxwLreTE8bXHuaSx3Ylzg,3071
 stjames/workflows/admet.py,sha256=h8ph6oeRCxU3-_jqRRWPg3RZcheu9JzCHiWqSC9VYKY,1296
-stjames/workflows/basic_calculation.py,sha256=ZX3KwhfyyCTjc2ougQIL4If7gtwZP9WjqpL45mBquW0,573
+stjames/workflows/basic_calculation.py,sha256=sAgHBcNHE72ZbZPB9vyZShALRC4zOVw6It6cpJlbX2A,911
 stjames/workflows/bde.py,sha256=g_In-caftXiimrhfdptHjpfrYQUs3vF58qYmRnaTN8g,10825
 stjames/workflows/conformer.py,sha256=18aO6ngMBeGAmQkBdLGCCHr398RIYr1v2hD2IT1u4cc,3005
 stjames/workflows/conformer_search.py,sha256=4yPEKIIedeaVvaAwgjwC1FxiHqM6n2zOF6c9Yk_q1oA,13513
 stjames/workflows/descriptors.py,sha256=T4tc7xdtBdxESGO86KR323jPQ2pgwxBqgV0khA6MEgQ,584
-stjames/workflows/docking.py,sha256=CgpLjMfpPka1fcg0VJPeyJCOnZjnJTrgfNeMAKiX4zM,3897
+stjames/workflows/docking.py,sha256=Lc3xB2H_hu0bxlGQBurDtytZfVwSFCgcTyJFWjMDhKI,3857
+stjames/workflows/double_ended_ts_search.py,sha256=ovJgEVFc6c3mijCE3TKAY70YvqNmAZ5Y4XgV4-tIxBI,3127
 stjames/workflows/electronic_properties.py,sha256=GT3-NC7w-dbcOJ-3AzJ7LgzH6frTbiH2Iyb9BCa-SvY,4112
-stjames/workflows/fukui.py,sha256=T6TDg-lcE-sfTDVpa3KFBenLe7PGUO2QrQ2jNuw_iiU,1756
+stjames/workflows/fukui.py,sha256=095GDGSSEc5PDD1aoKM8J7icgR5tfwS5Bs9XxFQHge4,2387
 stjames/workflows/hydrogen_bond_basicity.py,sha256=q9eXty68ZyCmrB6G_8bfeOT8Ui_IQquRPu6z-3rNreQ,1589
 stjames/workflows/ion_mobility.py,sha256=rvvAt4ZD-Npl0tHL7TEuaS3XKjHiMkSZVzyJoivdyps,1665
 stjames/workflows/irc.py,sha256=ZP7icylW8rgo_Uh7h3bmyumn0ru1IyF-61nP5Jnmq3M,3402
 stjames/workflows/macropka.py,sha256=KRIyk4gsSYL3eqyzCDndStGLwjWSo60cgCAzvAoD1Nk,3754
-stjames/workflows/molecular_dynamics.py,sha256=kxugE73Ntzpj-xpJSoQ1EwGzXXdvi_NTyeP4913EVwE,3173
+stjames/workflows/molecular_dynamics.py,sha256=HqWNxxPSAphfI0DdbTERFkq8UeBjEvhnA_ETv0xw_RY,3522
 stjames/workflows/multistage_opt.py,sha256=SpbA8hNvktnlLS7C-9mBNGluBSrdVS8ygHl1C4TzWcI,16499
-stjames/workflows/nmr.py,sha256=LKIOJHenzPTALv2ov5cImMknZ4JiYjxnpVSctbIRKvA,2708
+stjames/workflows/nmr.py,sha256=Fw7k_ZvIaxpAxkdgW2xMORhaI5s5BY_v7_VEPG1Ylgc,2710
 stjames/workflows/pka.py,sha256=j3vBh2YM3nJzJ1XJKPsmYahRCeaU9n3P-G-u9_moaFw,2065
 stjames/workflows/pose_analysis_md.py,sha256=ES0XlzaLpTjhLrNvcB0zFZa1b1ZHXekN72EbLsx0Skw,4723
 stjames/workflows/protein_cofolding.py,sha256=6WWbVOGzFjIRgQLMmMVODfIxo1jYFmRS1xnJmN0kOBw,3016
@@ -61,8 +64,8 @@ stjames/workflows/solubility.py,sha256=kGfVyPPGDLRpf2j6dSY7woCkfsoXSbUzdSImA4mcM
 stjames/workflows/spin_states.py,sha256=0degmE-frovgoXweshZyjfjqL7nkbaFoO9YoJhvQnaI,4748
 stjames/workflows/tautomer.py,sha256=7eYKziGPg8Km6lfowTzSkgJfJ4SHUPrAmnTf8Bi-SB0,1164
 stjames/workflows/workflow.py,sha256=OE05pt2ZOd8TzTOlBngXCVg9wv_553ZR60VNRPlq0f8,1953
-stjames-0.0.98.dist-info/licenses/LICENSE,sha256=i7ehYBS-6gGmbTcgU4mgk28pyOx2kScJ0kcx8n7bWLM,1084
-stjames-0.0.98.dist-info/METADATA,sha256=Nc6lMpSB2hbXb3cTv79Z1WDDGfQpUe3O3JLjjFi6UMs,1724
-stjames-0.0.98.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-stjames-0.0.98.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
-stjames-0.0.98.dist-info/RECORD,,
+stjames-0.0.101.dist-info/licenses/LICENSE,sha256=i05z7xEhyrg6f8j0lR3XYjShnF-MJGFQ-DnpsZ8yiVI,1084
+stjames-0.0.101.dist-info/METADATA,sha256=TNvGMRniR9D4VJTlQygqa0ZuEtgVLsqeN9jfkNRLdxQ,1725
+stjames-0.0.101.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+stjames-0.0.101.dist-info/top_level.txt,sha256=FYCwxl6quhYOAgG-mnPQcCK8vsVM7B8rIUrO-WrQ_PI,8
+stjames-0.0.101.dist-info/RECORD,,

{stjames-0.0.98.dist-info → stjames-0.0.101.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) Rowan (https://rowansci.com)
+Copyright (c) Rowan Scientific Corporation
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal