westpa 2022.10__cp312-cp312-macosx_11_0_arm64.whl → 2022.12__cp312-cp312-macosx_11_0_arm64.whl

westpa/core/data_manager.py

@@ -178,7 +178,7 @@ istate_dtype = np.dtype(
         ('basis_state_id', seg_id_dtype),  # Which basis state this state was generated from
         ('istate_type', istate_type_dtype),  # What type this initial state is (generated or basis)
         ('istate_status', istate_status_dtype),  # Whether this initial state is ready to go
-        ('basis_auxref', vstr_dtype),
+        ('basis_auxref', vstr_dtype),  # for start states to point back to their original location
     ]
 )
 
@@ -1549,7 +1549,7 @@ def create_dataset_from_dsopts(group, dsopts, shape=None, dtype=None, data=None,
         #        dsopts['file'] = str(dsopts['file']).format(n_iter=n_iter)
         h5_auxfile = h5io.WESTPAH5File(dsopts['file'].format(n_iter=n_iter))
         h5group = group
-        if not ("iter_" + str(n_iter).zfill(8)) in h5_auxfile:
+        if ("iter_" + str(n_iter).zfill(8)) not in h5_auxfile:
             h5_auxfile.create_group("iter_" + str(n_iter).zfill(8))
         group = h5_auxfile[('/' + "iter_" + str(n_iter).zfill(8))]
 
@@ -1652,7 +1652,7 @@ def create_dataset_from_dsopts(group, dsopts, shape=None, dtype=None, data=None,
     if 'file' in list(dsopts.keys()):
         import h5py
 
-        if not dsopts['h5path'] in h5group:
+        if dsopts['h5path'] not in h5group:
             h5group[dsopts['h5path']] = h5py.ExternalLink(
                 dsopts['file'].format(n_iter=n_iter), ("/" + "iter_" + str(n_iter).zfill(8) + "/" + dsopts['h5path'])
             )

westpa/core/h5io.py

@@ -344,10 +344,10 @@ def label_axes(h5object, labels, units=None):
     if len(units) and len(units) != len(labels):
         raise ValueError('number of units labels does not match number of axes')
 
-    h5object.attrs['axis_labels'] = np.array([np.string_(i) for i in labels])
+    h5object.attrs['axis_labels'] = np.array([np.bytes_(i) for i in labels])
 
     if len(units):
-        h5object.attrs['axis_units'] = np.array([np.string_(i) for i in units])
+        h5object.attrs['axis_units'] = np.array([np.bytes_(i) for i in units])
 
 
 NotGiven = object()

westpa/core/kinetics/matrates.py

@@ -61,7 +61,7 @@ def get_steady_state(rates):
 
     vals = np.abs(vals)
     log.debug('eigenvalues: {!r}'.format(list(reversed(sorted(vals)))))
-    asort = np.argsort(vals)
+    asort = np.argsort(vals, kind='stable')
     vec = vecs[:, asort[-1]]
     ss = np.abs(vec)
 

westpa/core/propagators/executable.py

@@ -1,7 +1,6 @@
 import logging
 import os
 import shutil
-import random
 import signal
 import subprocess
 import sys
@@ -12,6 +11,7 @@ import pickle
 from io import BytesIO
 
 import numpy as np
+from numpy.random import MT19937, Generator
 
 import westpa
 from westpa.core.extloader import get_object
@@ -228,6 +228,9 @@ class ExecutablePropagator(WESTPropagator):
         self.initial_state_ref_template = config['west', 'data', 'data_refs', 'initial_state']
         store_h5 = config.get(['west', 'data', 'data_refs', 'iteration']) is not None
 
+        # Create a persistent RNG for each worker
+        self.rng = Generator(MT19937())
+
         # Load additional environment variables for all child processes
         self.addtl_child_environ.update({k: str(v) for k, v in (config['west', 'executable', 'environ'] or {}).items()})
 
@@ -278,7 +281,7 @@ class ExecutablePropagator(WESTPropagator):
         self.data_info['log'] = {'name': 'seglog', 'loader': seglog_loader, 'enabled': store_h5, 'filename': None, 'dir': False}
 
         # Grab config from west.executable.datasets, else fallback to west.data.datasets.
-        dataset_configs = config.get(["west", "executable", "datasets"], config.get(['west', 'data', 'datasets'], {}))
+        dataset_configs = config.get(["west", "executable", "datasets"]) or config.get(['west', 'data', 'datasets'], {})
         for dsinfo in dataset_configs:
             try:
                 dsname = dsinfo['name']
@@ -332,11 +335,11 @@ class ExecutablePropagator(WESTPropagator):
         ``subprocess.Popen()``. Every child process executed by ``exec_child()`` gets these.'''
 
         return {
-            self.ENV_RAND16: str(random.randint(0, 2**16)),
-            self.ENV_RAND32: str(random.randint(0, 2**32)),
-            self.ENV_RAND64: str(random.randint(0, 2**64)),
-            self.ENV_RAND128: str(random.randint(0, 2**128)),
-            self.ENV_RANDFLOAT: str(random.random()),
+            self.ENV_RAND16: str(self.rng.integers(2**16, dtype=np.uint16)),
+            self.ENV_RAND32: str(self.rng.integers(2**32, dtype=np.uint32)),
+            self.ENV_RAND64: str(self.rng.integers(2**64, dtype=np.uint64)),
+            self.ENV_RAND128: str(int(self.rng.integers(2**64, dtype=np.uint64)) + int(self.rng.integers(2**64, dtype=np.uint64))),
+            self.ENV_RANDFLOAT: str(self.rng.random()),
         }
 
     def exec_child(self, executable, environ=None, stdin=None, stdout=None, stderr=None, cwd=None):
@@ -375,6 +378,7 @@ class ExecutablePropagator(WESTPropagator):
         # Do a subprocess.Popen.wait() to let the Popen instance (and subprocess module) know that
         # we are done with the process, and to get a more friendly return code
         rc = proc.wait()
+
         return (rc, rusage)
 
     def exec_child_from_child_info(self, child_info, template_args, environ):

westpa/core/sim_manager.py

@@ -1,7 +1,6 @@
 import logging
 import math
 import operator
-import random
 import time
 from datetime import timedelta
 from pickle import PickleError
@@ -9,6 +8,7 @@ from itertools import zip_longest
 from collections import Counter
 
 import numpy as np
+from numpy.random import Generator, MT19937
 
 import westpa
 from .data_manager import weight_dtype
@@ -98,6 +98,9 @@ class WESimManager:
         # Tracking of binning
         self.bin_mapper_hash = None  # Hash of bin mapper from most recently-run WE, for use by post-WE analysis plugins
 
+        # Pseudo Random Number Generator
+        self.rng = Generator(MT19937())
+
     def register_callback(self, hook, function, priority=0):
         '''Registers a callback to execute during the given ``hook`` into the simulation loop. The optional
         priority is used to order when the function is called relative to other registered callbacks.'''
@@ -229,13 +232,15 @@ class WESimManager:
 
     def get_bstate_pcoords(self, basis_states, label='basis'):
         '''For each of the given ``basis_states``, calculate progress coordinate values
-        as necessary.  The HDF5 file is not updated.'''
+        as necessary.  The HDF5 file is not updated. The BasisState objects are explicitly
+        copied from the futures in order to retain auxdata/restart files (under BasisState.data)
+        from certain work managers (e.g., the ``processes`` work manager.)'''
 
         self.rc.pstatus('Calculating progress coordinate values for {} states.'.format(label))
         futures = [self.work_manager.submit(wm_ops.get_pcoord, args=(basis_state,)) for basis_state in basis_states]
         fmap = {future: i for (i, future) in enumerate(futures)}
         for future in self.work_manager.as_completed(futures):
-            basis_states[fmap[future]].pcoord = future.get_result().pcoord
+            basis_states[fmap[future]] = future.get_result()
 
     def report_basis_states(self, basis_states, label='basis'):
         pstatus = self.rc.pstatus
@@ -554,7 +559,7 @@ class WESimManager:
         updated_states = []
         for _i in range(n_istates_needed):
             # Select a basis state according to its weight
-            ibstate = np.digitize([random.random()], self.next_iter_bstate_cprobs)
+            ibstate = np.digitize([self.rng.random()], self.next_iter_bstate_cprobs)
             basis_state = self.next_iter_bstates[ibstate[0]]
             initial_state = self.data_manager.create_initial_states(1, n_iter=self.n_iter + 1)[0]
             initial_state.iter_created = self.n_iter

westpa/core/states.py

@@ -20,7 +20,7 @@ class BasisState:
     '''
 
     def __init__(self, label, probability, pcoord=None, auxref=None, state_id=None):
-        self.label = str(label, encoding="UTF-8") if type(label) is bytes else label
+        self.label = str(label, encoding="UTF-8") if isinstance(label, bytes) else label
         self.probability = probability
         self.pcoord = np.atleast_1d(pcoord)
         self.auxref = auxref
@@ -28,7 +28,7 @@ class BasisState:
         self.data = {}
 
     def __repr__(self):
-        return '{} state_id={self.state_id!r} label={self.label!r} prob={self.probability!r} pcoord={self.pcoord!r}>'.format(
+        return '{} state_id={self.state_id!s} label={self.label!s} prob={self.probability!s} pcoord={self.pcoord!s}>'.format(
             object.__repr__(self)[:-1], self=self
         )
 
@@ -43,7 +43,7 @@ class BasisState:
         max_auxref_len = max(8, max(len(state.auxref or '') for state in states))
         fmt = (
             '{state.label:<{max_label_len}s}    {state.probability:12.7g}    {auxref_str:<{max_auxref_len}s}'
-            '    # state_id={state_id_str:s}    pcoord={pcoord_str}\n'
+            '    # state_id={state_id_str:s}    pcoord={pcoord_str:s}\n'
         )
         fileobj.write(
             '# {:{max_label_len}s}    {:>12s}    {:{max_auxref_len}s}\n'.format(
@@ -52,7 +52,7 @@ class BasisState:
         )
         for state in states:
             state_id_str = str(state.state_id) if state.state_id is not None else 'None'
-            pcoord_str = str(list(state.pcoord))
+            pcoord_str = str(state.pcoord.tolist())
             auxref_str = 'None' if state.auxref == b'' or state.auxref == "b''" else str(state.auxref)
             fileobj.write(
                 fmt.format(
@@ -99,7 +99,7 @@ class BasisState:
             try:
                 probability = float(fields[1])
             except ValueError:
-                raise ValueError('invalid probability ({!r}) {} line {:d}'.format(fields[1], statefile, lineno))
+                raise ValueError('invalid probability ({!s}) {} line {:d}'.format(fields[1], statefile, lineno))
 
             try:
                 auxref = fields[2].strip()
@@ -201,7 +201,7 @@ class InitialState:
         self.data = {}
 
     def __repr__(self):
-        return '{} state_id={self.state_id!r} istate_type={self.istate_type!r} basis_state_id={self.basis_state_id!r} iter_created={self.iter_created!r} pcoord={self.pcoord!r}>'.format(
+        return '{} state_id={self.state_id!s} istate_type={self.istate_type!s} basis_state_id={self.basis_state_id!s} iter_created={self.iter_created!s} pcoord={self.pcoord!s}>'.format(
             object.__repr__(self)[:-1], self=self
         )
 
@@ -263,7 +263,7 @@ class TargetState:
         self.state_id = state_id
 
     def __repr__(self):
-        return '{} state_id={self.state_id!r} label={self.label!r} pcoord={self.pcoord!r}>'.format(
+        return '{} state_id={self.state_id!s} label={self.label!s} pcoord={self.pcoord!s}>'.format(
             object.__repr__(self)[:-1], self=self
         )
 

westpa/core/we_driver.py

@@ -1,9 +1,9 @@
 import logging
 import math
 import operator
-import random
 
 import numpy as np
+from numpy.random import Generator, MT19937
 
 import westpa
 from .segment import Segment
@@ -119,6 +119,8 @@ class WEDriver:
 
         self.avail_initial_states = None
 
+        self.rng = Generator(MT19937())
+
         # Make property for subgrouping function.
         self.subgroup_function = _group_walkers_identity
         self.subgroup_function_kwargs = {}
@@ -478,7 +480,7 @@ class WEDriver:
         # sees where this value falls among the (sorted) weights of the segments being merged;
         # this ensures that a walker with (e.g.) twice the weight of its brethren has twice the
         # probability of having its history selected for continuation
-        iparent = np.digitize((random.uniform(0, glom.weight),), cumul_weight)[0]
+        iparent = np.digitize((self.rng.uniform(0, glom.weight),), cumul_weight)[0]
         gparent_seg = segments[iparent]
 
         # Inherit history from this segment ("gparent" stands for "glom parent", as opposed to historical

westpa/mclib/__init__.py

@@ -2,10 +2,15 @@
 statistics.'''
 
 import numpy as np
+from numpy.random import Generator, MT19937
 
 from ._mclib import mcbs_correltime, get_bssize, mcbs_ci
 
 
+def msort(input_array):
+    return np.sort(input_array, axis=0)
+
+
 def mcbs_ci_correl(
     estimator_datasets,
     estimator,
@@ -98,6 +103,8 @@ def mcbs_ci_correl(
         # We don't try and pretend we're doing any error analysis.
         return return_set, return_set, return_set, 0, 1
 
+    rng = Generator(MT19937())  # RNG
+
     # We need to pre-generate the data; why not do it here?  We're already set up for it...
     precalc_kwargs = estimator_kwargs.copy()
     precalc_kwargs['stride'] = 1
@@ -144,10 +151,10 @@ def mcbs_ci_correl(
             n_sets=n_sets,
             args=args,
             kwargs=estimator_kwargs,
-            sort=np.msort,
+            sort=msort,
         ) + (correl_len,)
     else:
-        subsample = subsample or (lambda x: x[np.random.randint(len(x))])
+        subsample = subsample or (lambda x: x[rng.integers(len(x))])
         # Let's make sure we decimate every array properly...
         decim_list = {}
         for key, dset in estimator_datasets.items():
@@ -175,7 +182,7 @@ def mcbs_ci_correl(
             n_sets=n_sets,
             args=args,
             kwargs=estimator_kwargs,
-            sort=np.msort,
+            sort=msort,
         ) + (correl_len,)
 
 

westpa/oldtools/aframe/mcbs.py

@@ -6,6 +6,7 @@ import logging
 import math
 
 import numpy as np
+from numpy.random import Generator, MT19937
 
 import westpa
 from westpa.oldtools.aframe import AnalysisMixin
@@ -13,6 +14,10 @@ from westpa.oldtools.aframe import AnalysisMixin
 log = logging.getLogger(__name__)
 
 
+def msort(input_array):
+    return np.sort(input_array, axis=0)
+
+
 class MCBSMixin(AnalysisMixin):
     def __init__(self):
         super().__init__()
@@ -96,12 +101,14 @@ def bootstrap_ci_ll(estimator, data, alpha, n_sets, storage, sort, eargs=(), ekw
     value ``fhat`` of the estimator must be pre-calculated to allocate ``storage``, then its value may be
     passed; otherwise, ``estimator(data,*eargs,**kwargs)`` will be called to calculate it.'''
 
+    rng = Generator(MT19937())
+
     if fhat is None:
         fhat = estimator(data, *eargs, **ekwargs)
     dlen = len(data)
 
     for iset in range(n_sets):
-        indices = np.random.randint(dlen, size=(dlen,))
+        indices = rng.integers(dlen, size=(dlen,))
         storage[iset] = estimator(data[indices], *eargs, **ekwargs)
 
     synth_sorted = sort(storage)
@@ -117,7 +124,7 @@ def bootstrap_ci_ll(estimator, data, alpha, n_sets, storage, sort, eargs=(), ekw
         del fhat, lb, ub, indices
 
 
-def bootstrap_ci(estimator, data, alpha, n_sets=None, sort=np.msort, eargs=(), ekwargs={}):
+def bootstrap_ci(estimator, data, alpha, n_sets=None, sort=msort, eargs=(), ekwargs={}):
     '''Perform a Monte Carlo bootstrap of a (1-alpha) confidence interval for the given ``estimator``.
     Returns (fhat, ci_lower, ci_upper), where fhat is the result of ``estimator(data, *eargs, **ekwargs)``,
     and ``ci_lower`` and ``ci_upper`` are the lower and upper bounds of the surrounding confidence

westpa/oldtools/aframe/plotting.py

@@ -66,10 +66,10 @@ else:
     cm_pdr = matplotlib.colors.LinearSegmentedColormap('pdr', _pdr_data, 2048)
     cm_pdr_r = cm_pdr.reversed()
 
-    matplotlib.cm.register_cmap('pdr', cm_pdr)
-    matplotlib.cm.register_cmap('pdr_r', cm_pdr_r)
-    matplotlib.cm.register_cmap('hovmol', cm_hovmol)
-    matplotlib.cm.register_cmap('hovmol_r', cm_hovmol_r)
+    matplotlib.colormaps.register(cmap=cm_pdr, name='pdr')
+    matplotlib.colormaps.register(cmap=cm_pdr_r, name='pdr_r')
+    matplotlib.colormaps.register(cmap=cm_hovmol, name='hovmol')
+    matplotlib.colormaps.register(cmap=cm_hovmol_r, name='hovmol_r')
 
     del cmap_data
 

westpa/oldtools/cmds/w_ttimes.py

@@ -2,6 +2,7 @@ import argparse
 import logging
 
 import numpy as np
+from numpy.random import Generator, MT19937
 
 import westpa
 
@@ -42,6 +43,8 @@ class WTTimesBase:
         self.fluxes = None
         self.rates = None
 
+        self.rng = Generator(MT19937())
+
     def add_args(self, parser, upcall=True):
         '''Add arguments to a parser common to all analyses of this type.'''
         if upcall:
@@ -162,7 +165,7 @@ class WTTimesBase:
                         end='',
                     )
                     westpa.rc.pflush()
-                    indices = np.random.randint(dlen, size=(dlen,))
+                    indices = self.rng.integers(dlen, size=(dlen,))
                     # syn_weights   = trans_weights[indices]
                     # syn_durations = trans_durations[indices]
                     # syn_fpts      = trans_fpts[indices]

westpa/oldtools/stats/edfs.py

@@ -42,7 +42,7 @@ class EDF:
                 raise TypeError('values and weights have different lengths')
 
         # Sort values
-        sort_indices = numpy.argsort(values)
+        sort_indices = numpy.argsort(values, kind='stable')
         values = values[sort_indices]
         weights = weights[sort_indices]
 

westpa/oldtools/stats/mcbs.py

@@ -5,6 +5,11 @@ Tools for Monte Carlo bootstrap error analysis
 import math
 
 import numpy as np
+from numpy.random import Generator, MT19937
+
+
+def msort(input_array):
+    return np.sort(input_array, axis=0)
 
 
 def add_mcbs_options(parser):
@@ -31,7 +36,7 @@ def get_bssize(alpha):
     return int(10 ** (math.ceil(-math.log10(alpha)) + 1))
 
 
-def bootstrap_ci(estimator, data, alpha, n_sets=None, args=(), kwargs={}, sort=np.msort, extended_output=False):
+def bootstrap_ci(estimator, data, alpha, n_sets=None, args=(), kwargs={}, sort=msort, extended_output=False):
     '''Perform a Monte Carlo bootstrap of a (1-alpha) confidence interval for the given ``estimator``.
     Returns (fhat, ci_lower, ci_upper), where fhat is the result of ``estimator(data, *args, **kwargs)``,
     and ``ci_lower`` and ``ci_upper`` are the lower and upper bounds of the surrounding confidence
@@ -69,8 +74,10 @@ def bootstrap_ci(estimator, data, alpha, n_sets=None, args=(), kwargs={}, sort=n
 
     f_synth = np.empty((n_sets,) + estimator_shape, dtype=estimator_dtype)
 
+    rng = Generator(MT19937())
+
     for i in range(0, n_sets):
-        indices = np.random.randint(dlen, size=(dlen,))
+        indices = rng.integers(dlen, size=(dlen,))
         f_synth[i] = estimator(data[indices], *args, **kwargs)
 
     f_synth_sorted = sort(f_synth)

westpa/westext/stringmethod/string_method.py

@@ -180,7 +180,7 @@ class DefaultStringMethod(WESTStringMethod):
                 ud[2:] = -self._kappan[ulen]
                 ld[:-2] = -self._kappan[ulen]
 
-                self._A[ulen] = np.mat([ud, d, ld])
+                self._A[ulen] = np.asmatrix([ud, d, ld])
 
             else:
                 self._A[ulen] = np.eye(ulen)

westpa/westext/weed/ProbAdjustEquil.py

@@ -62,7 +62,7 @@ def probAdjustEquil(binProb, rates, uncert, threshold=0.0, fullCalcClust=False,
     j = j[nzi]
 
     vals = ma.vstack((ratios_average.vals[i, j], ratios_average.vals[j, i]))
-    ias = ma.argsort(vals, axis=0, fill_value=np.inf)
+    ias = ma.argsort(vals, axis=0, kind='stable', fill_value=np.inf)
 
     ordered_ind = np.vstack((i, j))
     flip_ind = np.nonzero(ias[0, :])  # Find pairs in which to select ji rather than ij
@@ -73,7 +73,7 @@ def probAdjustEquil(binProb, rates, uncert, threshold=0.0, fullCalcClust=False,
     uncertij = ratios_average.uncert[iind, jind]  # Get the uncert for ij pairs
 
     count = uncertij.count()  # Count of the unmasked uncertainties
-    ias = ma.argsort(uncertij, fill_value=np.inf)  # Get the indices that would sort uncertij
+    ias = ma.argsort(uncertij, kind='stable', fill_value=np.inf)  # Get the indices that would sort uncertij
     iind = iind[ias[:count]]  # Sort the indices excluding masked/undefined values
     jind = jind[ias[:count]]
 

westpa/westext/weed/weed_driver.py

@@ -95,7 +95,15 @@ class WEEDDriver:
 
         with self.data_manager.lock:
             weed_global_group = self.data_manager.we_h5file.require_group('weed')
+            reweighting_history_dataset = weed_global_group.require_dataset(
+                'reweighting_history', (1,), maxshape=(None,), dtype=int
+            )
             last_reweighting = int(weed_global_group.attrs.get('last_reweighting', 0))
+            if last_reweighting > n_iter:
+                last_reweighting = n_iter - 1
+                reweighting_history = reweighting_history_dataset[:]
+                reweighting_history = reweighting_history[reweighting_history < n_iter]
+                reweighting_history_dataset.resize((reweighting_history.size), axis=0)
 
         if n_iter - last_reweighting < self.reweight_period:
             # Not time to reweight yet
@@ -172,6 +180,8 @@ class WEEDDriver:
             for bin, newprob in zip(bins, binprobs):
                 bin.reweight(newprob)
 
+            reweighting_history_dataset.resize((reweighting_history_dataset.shape[0] + 1), axis=0)
+            reweighting_history_dataset[-1] = n_iter
             weed_global_group.attrs['last_reweighting'] = n_iter
 
         assert (

westpa/westext/wess/wess_driver.py

@@ -112,7 +112,15 @@ class WESSDriver:
 
         with self.data_manager.lock:
             wess_global_group = self.data_manager.we_h5file.require_group('wess')
+            reweighting_history_dataset = wess_global_group.require_dataset(
+                'reweighting_history', (1,), maxshape=(None,), dtype=int
+            )
             last_reweighting = int(wess_global_group.attrs.get('last_reweighting', 0))
+            if last_reweighting > n_iter:
+                last_reweighting = n_iter - 1
+                reweighting_history = reweighting_history_dataset[:]
+                reweighting_history = reweighting_history[reweighting_history < n_iter]
+                reweighting_history_dataset.resize((reweighting_history.size), axis=0)
 
         if n_iter - last_reweighting < self.reweight_period:
             # Not time to reweight yet
@@ -197,6 +205,8 @@ class WESSDriver:
                 if len(bin):
                     bin.reweight(newprob)
 
+            reweighting_history_dataset.resize((reweighting_history_dataset.shape[0] + 1), axis=0)
+            reweighting_history_dataset[-1] = n_iter
             wess_global_group.attrs['last_reweighting'] = n_iter
 
         assert (

{westpa-2022.10.dist-info → westpa-2022.12.dist-info}/AUTHORS

@@ -4,18 +4,18 @@ in collaboration with Daniel Zuckerman (zuckermd@ohsu.edu)
 The original version of WESTPA was written by Matthew Zwier (matthew.zwier@drake.edu) 
 as part of his Ph.D. dissertation with Lillian Chong.
 
-Other contributors are the following (In alphabetical order)
+Other core contributors are the following (in alphabetical order)
 
 Joshua Adelman
-Alex DeGrave
-Page Harrison
-Joseph Kaus
-Patrick Pisciuneri
-A. J. Pratt
-Nicholas Rego
+Anthony Bogetti
+Jeremy Leung
+AJ Pratt
+John Russo
 Ali Saglam
-David Wang
+Jeff Thompson
 Kim Wong
+Darian Yang
+She Zhang
 
 The work manager interface is derived from the ``concurrent.futures`` module
 of Python 3.2 by Brian Quinlan, (C) 2011 the Python Software Foundation.

{westpa-2022.10.dist-info → westpa-2022.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: westpa
-Version: 2022.10
+Version: 2022.12
 Summary: WESTPA is a package for constructing and running stochastic simulations using the "weighted ensemble" approach of Huber and Kim (1996).
 Home-page: http://github.com/westpa/westpa
 License: MIT
@@ -12,13 +12,14 @@ Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Cython
-Requires-Python: >=3.6
+Requires-Python: >=3.9
 License-File: LICENSE
 License-File: AUTHORS
-Requires-Dist: numpy <2,>=1.16.0
-Requires-Dist: scipy >=0.19.1
-Requires-Dist: h5py >=2.10
-Requires-Dist: mdtraj >=1.9.5
+Requires-Dist: numpy<3,>=1.25.0; python_version >= "3.10"
+Requires-Dist: numpy<2,>=1.25.0; python_version < "3.10"
+Requires-Dist: scipy>=0.19.1
+Requires-Dist: h5py>=2.10
+Requires-Dist: mdtraj>=1.9.5
 Requires-Dist: pyyaml
 Requires-Dist: pyzmq
 Requires-Dist: matplotlib
@@ -27,19 +28,28 @@ Requires-Dist: ipykernel
 Requires-Dist: tqdm
 Requires-Dist: pandas
 Requires-Dist: tables
-Provides-Extra: dev
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: pytest-cov ; extra == 'dev'
-Requires-Dist: pytest-rerunfailures ; extra == 'dev'
-Requires-Dist: pytest-timeout ; extra == 'dev'
-Requires-Dist: pre-commit ; extra == 'dev'
-Provides-Extra: mpi
-Requires-Dist: mpi4py ; extra == 'mpi'
 Provides-Extra: tests
-Requires-Dist: pytest ; extra == 'tests'
-Requires-Dist: pytest-cov ; extra == 'tests'
-Requires-Dist: pytest-rerunfailures ; extra == 'tests'
-Requires-Dist: pytest-timeout ; extra == 'tests'
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: pytest-cov; extra == "tests"
+Requires-Dist: pytest-rerunfailures; extra == "tests"
+Requires-Dist: pytest-timeout; extra == "tests"
+Provides-Extra: mpi
+Requires-Dist: mpi4py; extra == "mpi"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-rerunfailures; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 ===============
 WESTPA 2.0 
@@ -105,7 +115,7 @@ WESTPA is free software, licensed under the terms of the MIT License. See the fi
 Requirements
 ------------
 
-WESTPA is written in Python and requires version 3.7 or later. WESTPA also requires a number of Python scientific software packages. 
+WESTPA is written in Python and requires version 3.9 or later. WESTPA also requires a number of Python scientific software packages.
 The simplest way to meet these requirements is to download the
 Anaconda Python distribution from www.anaconda.com (free for all users).
 
@@ -137,7 +147,7 @@ See the install instructions on our `wiki`_ for more detailed information.
 
 To install from source (**not recommended**), start by downloading the corresponding tar.gz file from the `releases page`_. After downloading the file, unpack the file and install WESTPA by executing the following::
 
-    tar xvzf westpa-2022.09.tar.gz
+    tar xvzf westpa-2022.11.tar.gz
     cd westpa
     python -m pip install -e .