westpa 2022.8__cp311-cp311-macosx_10_9_x86_64.whl → 2022.10__cp311-cp311-macosx_10_9_x86_64.whl

westpa/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-04-15T22:37:00-0400",
+ "date": "2024-05-30T14:33:52-0400",
  "dirty": false,
  "error": null,
- "full-revisionid": "587296bd42835960dc67dc3e91ead8f4dd2c6d97",
- "version": "2022.08"
+ "full-revisionid": "40fe71e4e393b47e0a231b178add25696e469405",
+ "version": "2022.10"
 }
 '''  # END VERSION_JSON
 

westpa/analysis/core.py

@@ -298,8 +298,8 @@ class Iteration:
     def basis_state_summaries(self):
         """pd.DataFrame: Basis state summary data."""
         df = pd.DataFrame(self.h5group['ibstates']['bstate_index'][:])
-        df['label'] = tostr(df['label'].str)
-        df['auxref'] = tostr(df['auxref'].str)
+        df['label'] = df['label'].str.decode('UTF-8')
+        df['auxref'] = df['auxref'].str.decode('UTF-8')
         return df
 
     @property
@@ -325,7 +325,7 @@ class Iteration:
         """pd.DataFrame or None: Target state summary data."""
         if self.has_target_states:
             df = pd.DataFrame(self.h5group['tstates']['index'][:])
-            df['label'] = tostr(df['label'].str)
+            df['label'] = df['label'].str.decode('UTF-8')
 
             return df
         else:

westpa/cli/core/w_states.py

@@ -157,7 +157,7 @@ def initialize(mode, bstates, _bstate_file, tstates, _tstate_file):
                             bstate.probability *= pscale
 
                     # Assign progress coordinates to basis states
-                    sim_manager.get_bstate_pcoords(basis_states, n_iter)
+                    sim_manager.get_bstate_pcoords(basis_states)
                     data_manager.create_ibstate_group(basis_states, n_iter)
                     sim_manager.report_basis_states(basis_states)
 

westpa/cli/tools/w_ipa.py

@@ -157,11 +157,11 @@ class WIPI(WESTParallelTool):
         # print(str(to_hash).encode('base64'))
         if self.debug_mode:
             for iarg, arg in enumerate(to_hash):
-                if not isinstance(arg, list):
-                    print('arg {num:02d} -- {arg:<20}'.format(num=iarg, arg=arg))
-                else:
+                if isinstance(arg, list):
                     for il, l in enumerate(arg):
-                        print('arg {num:02d} -- {arg:<20}'.format(num=il + iarg, arg=l))
+                        print('arg {num:02d} -- {arg:<20}'.format(num=il + iarg, arg=h5io.tostr(l)))
+                else:
+                    print('arg {num:02d} -- {arg:<20}'.format(num=iarg, arg=h5io.tostr(arg)))
             # print('args: {}'.format(to_hash))
         # This SHOULD produce the same output, maybe?  That would be nice, anyway.
         # But we'll need to test it more.

westpa/cli/tools/w_pdist.py

@@ -423,7 +423,10 @@ Command-line options
             lb, ub = self.data_range[idim]
             # Advance just beyond the upper bound of the range, so that we catch
             # the maximum in the histogram
-            ub *= 1.01
+            if ub > 0:
+                ub *= 1.01
+            else:
+                ub /= 1.01
 
             boundset = np.linspace(lb, ub, bins + 1)
             midpoints = (boundset[:-1] + boundset[1:]) / 2.0
@@ -440,7 +443,10 @@ Command-line options
             lb, ub = self.data_range[idim]
             # Advance just beyond the upper bound of the range, so that we catch
             # the maximum in the histogram
-            ub *= 1.01
+            if ub > 0:
+                ub *= 1.01
+            else:
+                ub /= 1.01
 
             boundset = np.linspace(lb, ub, bins[idim] + 1)
             midpoints = (boundset[:-1] + boundset[1:]) / 2.0

westpa/core/_rc.py

@@ -1,12 +1,13 @@
 """WEST run control and configuration routines"""
 
-import errno
-import logging
 import math
 import os
 import sys
+import errno
+import logging
 import warnings
 from copy import deepcopy
+from datetime import timedelta
 
 import numpy as np
 
@@ -231,6 +232,21 @@ class WESTRC:
         self.config_logging()
         self.config['args'] = {k: v for k, v in args.__dict__.items() if not k.startswith('_')}
         self.process_config()
+        self.time_config()
+
+    def time_config(self):
+        '''Convert non-pyYAML accepted time formats into seconds'''
+        max_run_wallclock = self.config.get(['west', 'propagation', 'max_run_wallclock'], None)
+        if isinstance(max_run_wallclock, str):
+            time_formats = ['days', 'hours', 'minutes', 'seconds']
+            wallclock_str = max_run_wallclock.split(':')
+            kwargs = {key: int(val) for key, val in zip(time_formats[-len(wallclock_str) :], wallclock_str)}
+            try:
+                diff = int(timedelta(**kwargs).total_seconds())
+                self.config['west']['propagation']['max_run_wallclock'] = diff
+                log.debug(f'Automatically converted {max_run_wallclock=} to {diff}')
+            except ValueError:
+                log.debug(f'Failed to convert {max_run_wallclock=} to seconds.')
 
     def process_config(self):
         log.debug('config: {!r}'.format(self.config))

westpa/core/binning/mab.py

@@ -8,21 +8,161 @@ from os.path import expandvars
 log = logging.getLogger(__name__)
 
 
+class MABBinMapper(FuncBinMapper):
+    """
+    Adaptively place bins in between minimum and maximum segments along
+    the progress coordinte. Extrema and bottleneck segments are assigned
+    to their own bins.
+
+    """
+
+    def __init__(
+        self,
+        nbins,
+        direction=None,
+        skip=None,
+        bottleneck=True,
+        pca=False,
+        mab_log=False,
+        bin_log=False,
+        bin_log_path="$WEST_SIM_ROOT/binbounds.log",
+    ):
+        """
+        Parameters
+        ----------
+        nbins : list of int
+            List of int for nbins in each dimension.
+        direction : Union(list of int, None), default: None
+            List of int for 'direction' in each dimension.
+            Direction options are as follows:
+                0   : default split at leading and lagging boundaries
+                1   : split at leading boundary only
+                -1  : split at lagging boundary only
+                86  : no splitting at either leading or lagging boundary
+        skip : Union(list of int, None), default: None
+            List of int for each dimension. Default None for skip=0.
+            Set to 1 to 'skip' running mab in a dimension.
+        bottleneck : bool, default: True
+            Whether to turn on or off bottleneck walker splitting.
+        pca : bool, default: False
+            Can be True or False (default) to run PCA on pcoords before bin assignment.
+        mab_log : bool, default: False
+            Whether to output mab info to west.log.
+        bin_log : bool, default: False
+            Whether to output mab bin boundaries to bin_log_path file.
+        bin_log_path : str, default: "$WEST_SIM_ROOT/binbounds.log"
+            Path to output bin boundaries.
+
+        """
+        # Verifying parameters
+        if nbins is None:
+            raise ValueError("nbins_per_dim is missing")
+        ndim = len(nbins)
+
+        if direction is None:
+            direction = [0] * ndim
+        elif len(direction) != ndim:
+            direction = [0] * ndim
+            log.warning("Direction list is not the correct dimensions, setting to defaults.")
+
+        if skip is None:
+            skip = [0] * ndim
+        elif len(skip) != ndim:
+            skip = [0] * ndim
+            log.warning("Skip list is not the correct dimensions, setting to defaults.")
+
+        kwargs = dict(
+            nbins_per_dim=nbins,
+            direction=direction,
+            skip=skip,
+            bottleneck=bottleneck,
+            pca=pca,
+            mab_log=mab_log,
+            bin_log=bin_log,
+            bin_log_path=bin_log_path,
+        )
+
+        n_total_bins = self.determine_total_bins(**kwargs)
+
+        super().__init__(map_mab, n_total_bins, kwargs=kwargs)
+
+    def determine_total_bins(self, nbins_per_dim, direction, skip, bottleneck, **kwargs):
+        """
+        The following is neccessary because functional bin mappers need to "reserve"
+        bins and tell the sim manager how many bins they will need to use, this is
+        determined by taking all direction/skipping info into account.
+
+        Parameters
+        ----------
+        nbins_per_dim : int
+            Number of total bins in each direction.
+        direction : list of int
+            Direction in each dimension. See __init__ for more information.
+        skip : list of int
+            List of 0s and 1s indicating whether to skip each dimension.
+        bottleneck : bool
+            Whether to include separate bin for bottleneck walker(s).
+        **kwargs : dict
+            Arbitary keyword arguments. Contains unneeded MAB parameters.
+
+        Returns
+        -------
+        n_total_bins : int
+            Number of total bins.
+
+        """
+        n_total_bins = np.prod(nbins_per_dim)
+        ndim = len(nbins_per_dim)
+        for i in range(ndim):
+            if skip[i] == 0:
+                if direction[i] != 0:
+                    n_total_bins += 1 + 1 * bottleneck
+                else:
+                    n_total_bins += 2 + 2 * bottleneck
+            else:
+                n_total_bins -= nbins_per_dim[i] - 1
+                n_total_bins += 1 * ndim  # or else it will be one bin short
+        return n_total_bins
+
+
 def map_mab(coords, mask, output, *args, **kwargs):
-    '''Binning which adaptively places bins based on the positions of extrema segments and
+    """
+    Binning which adaptively places bins based on the positions of extrema segments and
     bottleneck segments, which are where the difference in probability is the greatest
     along the progress coordinate. Operates per dimension and places a fixed number of
     evenly spaced bins between the segments with the min and max pcoord values. Extrema and
-    bottleneck segments are assigned their own bins.'''
-
-    pca = kwargs.get("pca")
-    bottleneck = kwargs.get("bottleneck")
-    direction = kwargs.get("direction")
-    skip = kwargs.get("skip")
+    bottleneck segments are assigned their own bins.
+
+    Parameters
+    ----------
+    coords : ndarray
+        An array with pcoord and weight info.
+    mask : ndarray
+        Array of 1 (True) and 0 (False), to filter out unwanted segment info.
+    output : list
+        The main list that, for each segment, holds the bin assignment.
+    *args : list
+        Variable length arguments.
+    **kwargs : dict
+        Arbitary keyword arguments. Contains most of the MAB-needed parameters.
+
+    Returns
+    ------
+    output : list
+        The main list that, for each segment, holds the bin assignment.
+
+    """
+
+    # Argument Processing
     nbins_per_dim = kwargs.get("nbins_per_dim")
-    mab_log = kwargs.get("mab_log")
-    bin_log = kwargs.get("bin_log")
     ndim = len(nbins_per_dim)
+    pca = kwargs.get("pca", False)
+    bottleneck = kwargs.get("bottleneck", True)
+    direction = kwargs.get("direction", ([0] * ndim))
+    skip = kwargs.get("skip", ([0] * ndim))
+    mab_log = kwargs.get("mab_log", False)
+    bin_log = kwargs.get("bin_log", False)
+    bin_log_path = kwargs.get("bin_log_path", "$WEST_SIM_ROOT/binbounds.log")
 
     if not np.any(mask):
         return output
@@ -135,12 +275,18 @@ def map_mab(coords, mask, output, *args, **kwargs):
     # which is two per dimension unless there is a direction specified
     # in a particluar dimension, then it's just one
     bottleneck_base = boundary_base
+    n_bottleneck_filled = 0
 
     for i in range(0, ndim):
-        if direction[i] != 0:
+        # for single direction, 1 boundary walker
+        if direction[i] == 1 or direction[i] == -1:
             bottleneck_base += 1
-        else:
+        # 2 boundary walkers with 0 direction
+        elif direction[i] == 0:
             bottleneck_base += 2
+        # for 86 direction, no boundary walkers so offset of 0
+        elif direction[i] == 86:
+            bottleneck_base += 0
 
     # if a dimension is being "skipped", leave only one bin total as
     # the offset
@@ -167,36 +313,42 @@ def map_mab(coords, mask, output, *args, **kwargs):
 
                 # assign bottlenecks, taking directionality into account
                 if bottleneck:
-                    if direction[n] < 0:
+                    if direction[n] == -1:
                         if coord == flipdifflist[n]:
                             holder = bottleneck_base + n
                             special = True
+                            n_bottleneck_filled += 1
                             break
 
-                    if direction[n] > 0:
+                    if direction[n] == 1:
                         if coord == difflist[n]:
                             holder = bottleneck_base + n
                             special = True
+                            n_bottleneck_filled += 1
                             break
 
-                    if direction[n] == 0:
+                    # both directions when using 0 or with
+                    # special value of 86 for no lead/lag split
+                    if direction[n] == 0 or direction[n] == 86:
                         if coord == difflist[n]:
                             holder = bottleneck_base + n
                             special = True
+                            n_bottleneck_filled += 1
                             break
                         elif coord == flipdifflist[n]:
                             holder = bottleneck_base + n + 1
                             special = True
+                            n_bottleneck_filled += 1
                             break
 
                 # assign boundary walkers, taking directionality into account
-                if direction[n] < 0:
+                if direction[n] == -1:
                     if coord == minlist[n]:
                         holder = boundary_base + n
                         special = True
                         break
 
-                elif direction[n] > 0:
+                elif direction[n] == 1:
                     if coord == maxlist[n]:
                         holder = boundary_base + n
                         special = True
@@ -212,6 +364,14 @@ def map_mab(coords, mask, output, *args, **kwargs):
                         special = True
                         break
 
+                # special value for direction with no lead/lag split
+                elif direction[n] == 86:
+                    # westpa.rc.pstatus(f"No lead/lag split for dim {n}")
+                    # westpa.rc.pflush()
+                    # nornmally adds to special bin but here just leaving it forever empty
+                    # holder = boundary_base + n
+                    break
+
         # the following are for the "linear" portion
         if not special:
             for n in range(ndim):
@@ -248,56 +408,20 @@ def map_mab(coords, mask, output, *args, **kwargs):
 
     if bin_log and report:
         if westpa.rc.sim_manager.n_iter:
-            with open(expandvars("$WEST_SIM_ROOT/binbounds.log"), 'a') as bb_file:
-                bb_file.write(f'{westpa.rc.sim_manager.n_iter}\n')  # Iteration Number
+            with open(expandvars(bin_log_path), 'a') as bb_file:
+                # Iteration Number
+                bb_file.write(f'iteration: {westpa.rc.sim_manager.n_iter}\n')
+                bb_file.write('bin boundaries: ')
                 for n in range(ndim):
-                    bb_file.write(f'{np.linspace(minlist[n], maxlist[n], nbins_per_dim[n] + 1)}\t')  # Write binbounds per dim
-                bb_file.write(f'\n{minlist} {maxlist}\n')  # Min/Max pcoord
-                if bottleneck_base > boundary_base:
-                    bb_file.write(f'{flipdifflist} {difflist}\n\n')  # Bottlenecks
+                    # Write binbounds per dim
+                    bb_file.write(f'{np.linspace(minlist[n], maxlist[n], nbins_per_dim[n] + 1)}\t')
+                    # Min/Max pcoord
+                bb_file.write(f'\nmin/max pcoord: {minlist} {maxlist}\n')
+                bb_file.write(f'bottleneck bins: {n_bottleneck_filled}\n')
+                if n_bottleneck_filled > 0:
+                    # Bottlenecks bins exist (passes any of the if bottleneck: checks)
+                    bb_file.write(f'bottleneck pcoord: {flipdifflist} {difflist}\n\n')
                 else:
                     bb_file.write('\n')
 
     return output
-
-
-class MABBinMapper(FuncBinMapper):
-    '''Adaptively place bins in between minimum and maximum segments along
-    the progress coordinte. Extrema and bottleneck segments are assigned
-    to their own bins.'''
-
-    def __init__(self, nbins, direction=None, skip=None, bottleneck=True, pca=False, mab_log=False, bin_log=False):
-        # Verifying parameters
-        if nbins is None:
-            raise ValueError("nbins_per_dim is missing")
-        ndim = len(nbins)
-
-        if direction is None:
-            direction = [0] * ndim
-        elif len(direction) != ndim:
-            direction = [0] * ndim
-            log.warning("Direction list is not the correct dimensions, setting to defaults.")
-
-        if skip is None:
-            skip = [0] * ndim
-        elif len(skip) != ndim:
-            skip = [0] * ndim
-            log.warning("Skip list is not the correct dimensions, setting to defaults.")
-
-        kwargs = dict(
-            nbins_per_dim=nbins, direction=direction, skip=skip, bottleneck=bottleneck, pca=pca, mab_log=mab_log, bin_log=bin_log
-        )
-        # the following is neccessary because functional bin mappers need to "reserve"
-        # bins and tell the sim manager how many bins they will need to use, this is
-        # determined by taking all direction/skipping info into account
-        n_total_bins = np.prod(nbins)
-        for i in range(0, ndim):
-            if skip[i] == 0:
-                if direction[i] != 0:
-                    n_total_bins += 1 + 1 * bottleneck
-                else:
-                    n_total_bins += 2 + 2 * bottleneck
-            else:
-                n_total_bins -= nbins[i] - 1
-                n_total_bins += 1 * ndim  # or else it will be one bin short
-        super().__init__(map_mab, n_total_bins, kwargs=kwargs)

westpa/core/binning/mab_manager.py

@@ -11,7 +11,10 @@ log = logging.getLogger(__name__)
 
 
 class MABSimManager(WESimManager):
+    '''Subclass of WESimManager, modifying it so bin assignments will be done after all segments are done propagating.'''
+
     def initialize_simulation(self, basis_states, target_states, start_states, segs_per_state=1, suppress_we=False):
+        '''Making sure that that the MABBinMapper is not the outer bin.'''
         if len(target_states) > 0:
             if isinstance(self.system.bin_mapper, MABBinMapper):
                 log.error("MABBinMapper cannot be an outer binning scheme with a target state\n")

westpa/core/data_manager.py

@@ -47,6 +47,7 @@ import posixpath
 import sys
 import threading
 import time
+import builtins
 from operator import attrgetter
 from os.path import relpath, dirname
 
@@ -1523,7 +1524,10 @@ def normalize_dataset_options(dsopts, path_prefix='', n_iter=0):
     dtype = dsopts.get('dtype')
     if dtype:
         if isinstance(dtype, str):
-            dsopts['dtype'] = np.dtype(getattr(np, dtype))
+            try:
+                dsopts['dtype'] = np.dtype(getattr(np, dtype))
+            except AttributeError:
+                dsopts['dtype'] = np.dtype(getattr(builtins, dtype))
         else:
             dsopts['dtype'] = np.dtype(dtype)
 

westpa/core/h5io.py

@@ -9,14 +9,15 @@ import socket
 import sys
 import time
 import logging
+import warnings
 
 import h5py
 import numpy as np
 from numpy import index_exp
+from tables import NaturalNameWarning
 
 from mdtraj import Trajectory, join as join_traj
 from mdtraj.utils import in_units_of, import_, ensure_type
-from mdtraj.utils.six import string_types
 from mdtraj.formats import HDF5TrajectoryFile
 from mdtraj.formats.hdf5 import _check_mode, Frames
 
@@ -28,6 +29,7 @@ except ImportError:
     psutil = None
 
 log = logging.getLogger(__name__)
+warnings.filterwarnings('ignore', category=NaturalNameWarning)
 
 #
 # Constants and globals
@@ -551,7 +553,7 @@ class WESTIterationFile(HDF5TrajectoryFile):
                 node = self._get_node(where='/', name=name)
                 data = get_item(node, slice)
                 in_units = node.attrs.units
-                if not isinstance(in_units, string_types):
+                if not isinstance(in_units, str):
                     in_units = in_units.decode()
                 data = in_units_of(data, in_units, out_units)
                 return data

westpa/core/propagators/executable.py

@@ -277,18 +277,19 @@ class ExecutablePropagator(WESTPropagator):
         }
         self.data_info['log'] = {'name': 'seglog', 'loader': seglog_loader, 'enabled': store_h5, 'filename': None, 'dir': False}
 
-        dataset_configs = config.get(['west', 'executable', 'datasets']) or []
+        # Grab config from west.executable.datasets, else fallback to west.data.datasets.
+        dataset_configs = config.get(["west", "executable", "datasets"], config.get(['west', 'data', 'datasets'], {}))
         for dsinfo in dataset_configs:
             try:
                 dsname = dsinfo['name']
             except KeyError:
                 raise ValueError('dataset specifications require a ``name`` field')
 
-            if dsname != 'pcoord':
-                check_bool(dsinfo.setdefault('enabled', True))
-            else:
+            if dsname == 'pcoord':
                 # can never disable pcoord collection
                 dsinfo['enabled'] = True
+            else:
+                check_bool(dsinfo.setdefault('enabled', True))
 
             loader_directive = dsinfo.get('loader', None)
             if callable(loader_directive):

westpa/core/sim_manager.py

@@ -1,12 +1,12 @@
-from datetime import timedelta
-from itertools import zip_longest
 import logging
 import math
 import operator
-from pickle import PickleError
 import random
 import time
-
+from datetime import timedelta
+from pickle import PickleError
+from itertools import zip_longest
+from collections import Counter
 
 import numpy as np
 
@@ -114,28 +114,40 @@ class WESimManager:
         #   handles specifically the problem that causes in plugin loading.
         try:
             # Before checking for set membership of (priority, function.__name__, function), just check
-            #   function names for collisions in this hook.
-            hook_function_names = [callback[1] for callback in self._callback_table[hook]]
+            #   function hash for collisions in this hook.
+            hook_function_hash = [hash(callback[2]) for callback in self._callback_table[hook]]
         except KeyError:
             # If there's no entry in self._callback_table for this hook, then there definitely aren't any collisions
             #   because no plugins are registered to it yet in the first place.
             pass
         else:
-            # If there are plugins registered to this hook, check for duplicate names.
-            if function.__name__ in hook_function_names:
-                log.debug("This plugin has already been loaded, skipping")
-                return
+            # If there are plugins registered to this hook, check for duplicate hash, which will definitely have the same name, module, function.
+            try:
+                if hash(function) in hook_function_hash:
+                    log.info('{!r} has already been loaded, skipping'.format(function))
+                    return
+            except KeyError:
+                pass
 
         try:
             self._callback_table[hook].add((priority, function.__name__, function))
         except KeyError:
             self._callback_table[hook] = set([(priority, function.__name__, function)])
 
+        # Raise warning if there are multiple callback with same priority.
+        for priority, count in Counter([callback[0] for callback in self._callback_table[hook]]).items():
+            if count > 1:
+                log.warning(
+                    f'{count} callbacks in {hook} have identical priority {priority}. The order of callback execution is not guaranteed.'
+                )
+                log.warning(f'{hook}: {self._callback_table[hook]}')
+
         log.debug('registered callback {!r} for hook {!r}'.format(function, hook))
 
     def invoke_callbacks(self, hook, *args, **kwargs):
         callbacks = self._callback_table.get(hook, [])
-        sorted_callbacks = sorted(callbacks)
+        # Sort by priority, function name, then module name
+        sorted_callbacks = sorted(callbacks, key=lambda x: (x[0], x[1], x[2].__module__))
         for priority, name, fn in sorted_callbacks:
             log.debug('invoking callback {!r} for hook {!r}'.format(fn, hook))
             fn(*args, **kwargs)
@@ -404,7 +416,7 @@ class WESimManager:
         )
 
         total_prob = float(sum(segment.weight for segment in segments))
-        pstatus(f'1-prob: {1-total_prob:.4e}')
+        pstatus(f'1-prob: {1 - total_prob:.4e}')
 
         target_counts = self.we_driver.bin_target_counts
         # Do not include bins with target count zero (e.g. sinks, never-filled bins) in the (non)empty bins statistics

westpa/westext/hamsm_restarting/restart_driver.py

@@ -9,6 +9,7 @@ from westpa.cli.core import w_run
 from westpa.core.extloader import get_object
 from westpa.core.segment import Segment
 from westpa import analysis
+from westpa.core._rc import bins_from_yaml_dict
 
 import json
 
@@ -266,6 +267,10 @@ def msmwe_compute_ss(plugin_config, west_files):
     basis_pcoord_bounds = np.array(plugin_config.get('basis_pcoord_bounds', np.nan), dtype=float)
     target_pcoord_bounds = np.array(plugin_config.get('target_pcoord_bounds', np.nan), dtype=float)
 
+    user_bin_mapper = plugin_config.get('user_bin_mapper', None)
+    if user_bin_mapper is not None:
+        user_bin_mapper = bins_from_yaml_dict(user_bin_mapper)
+
     if np.isnan(basis_pcoord_bounds).any() or np.isnan(target_pcoord_bounds).any():
         log.critical(
             "Target and/or basis pcoord bounds were not specified. "
@@ -330,7 +335,7 @@ def msmwe_compute_ss(plugin_config, west_files):
     else:
         # FIXME: This gives the wrong shape, but loading from the clusterfile gives the right shape
         log.debug("clustering coordinates into " + str(n_clusters) + " clusters...")
-        model.cluster_coordinates(n_clusters, streaming=streaming)
+        model.cluster_coordinates(n_clusters, streaming=streaming, user_bin_mapper=user_bin_mapper)
 
     first_iter = 1
     model.get_fluxMatrix(n_lag, first_iter, last_iter)  # extracts flux matrix, output model.fluxMatrixRaw
@@ -790,7 +795,7 @@ class RestartDriver:
 
                 westpa.rc.pstatus(
                     f"\n\n===== Restart {restart_state['restarts_completed']}, "
-                    + f"Run {restart_state['runs_completed']+1} initializing =====\n"
+                    + f"Run {restart_state['runs_completed'] + 1} initializing =====\n"
                 )
 
                 westpa.rc.pstatus(
@@ -811,7 +816,7 @@ class RestartDriver:
                 log.info("New WE run ready!")
                 westpa.rc.pstatus(
                     f"\n\n===== Restart {restart_state['restarts_completed']}, "
-                    + f"Run {restart_state['runs_completed']+1} running =====\n"
+                    + f"Run {restart_state['runs_completed'] + 1} running =====\n"
                 )
 
                 w_run.run_simulation()
@@ -1144,7 +1149,7 @@ class RestartDriver:
         westpa.rc.pstatus(
             f"\n\n"
             f"===== Restart {restart_state['restarts_completed']}, "
-            + f"Run {restart_state['runs_completed']+1} initializing =====\n"
+            + f"Run {restart_state['runs_completed'] + 1} initializing =====\n"
         )
 
         westpa.rc.pstatus(

westpa/westext/stringmethod/string_method.py

@@ -1,7 +1,11 @@
 from abc import ABCMeta, abstractmethod, abstractproperty
-from collections import Iterable
 import logging
 
+try:
+    from collections.abc import Iterable
+except ImportError:
+    from collections import Iterable
+
 import numpy as np
 
 

westpa/work_managers/processes.py

@@ -1,11 +1,11 @@
-import logging
-import multiprocessing
 import os
-import random
-import signal
 import sys
+import random
+import logging
 import threading
 import traceback
+import multiprocessing
+from multiprocessing.queues import Empty
 
 import westpa.work_managers as work_managers
 from .core import WorkManager, WMFuture
@@ -61,7 +61,7 @@ class ProcessWorkManager(WorkManager):
         self.receive_thread = None
         self.pending = None
 
-        self.shutdown_received = False
+        self.shutdown_received = threading.Event()
         self.shutdown_timeout = shutdown_timeout or 1
 
     def task_loop(self):
@@ -74,37 +74,38 @@ class ProcessWorkManager(WorkManager):
         # (re)initialize random number generator in this process
         random.seed()
 
-        while not self.shutdown_received:
-            message, task_id, fn, args, kwargs = self.task_queue.get()[:5]
+        while not self.shutdown_received.is_set():
+            if not self.task_queue.empty():
+                message, task_id, fn, args, kwargs = self.task_queue.get()[:5]
 
-            if message == 'shutdown':
-                break
-
-            try:
-                result = fn(*args, **kwargs)
-            except BaseException as e:
-                result_tuple = ('exception', task_id, (e, traceback.format_exc()))
-            else:
-                result_tuple = ('result', task_id, result)
-            self.result_queue.put(result_tuple)
+                if message == 'shutdown':
+                    break
+                try:
+                    result = fn(*args, **kwargs)
+                except BaseException as e:
+                    result_tuple = ('exception', task_id, (e, traceback.format_exc()))
+                else:
+                    result_tuple = ('result', task_id, result)
+                self.result_queue.put(result_tuple)
 
         log.debug('exiting task_loop')
         return
 
     def results_loop(self):
-        while not self.shutdown_received:
-            message, task_id, payload = self.result_queue.get()[:3]
-
-            if message == 'shutdown':
-                break
-            elif message == 'exception':
-                future = self.pending.pop(task_id)
-                future._set_exception(*payload)
-            elif message == 'result':
-                future = self.pending.pop(task_id)
-                future._set_result(payload)
-            else:
-                raise AssertionError('unknown message {!r}'.format((message, task_id, payload)))
+        while not self.shutdown_received.is_set():
+            if not self.result_queue.empty():
+                message, task_id, payload = self.result_queue.get()[:3]
+
+                if message == 'shutdown':
+                    break
+                elif message == 'exception':
+                    future = self.pending.pop(task_id)
+                    future._set_exception(*payload)
+                elif message == 'result':
+                    future = self.pending.pop(task_id)
+                    future._set_result(payload)
+                else:
+                    raise AssertionError('unknown message {!r}'.format((message, task_id, payload)))
 
         log.debug('exiting results_loop')
 
@@ -142,36 +143,38 @@ class ProcessWorkManager(WorkManager):
             self.receive_thread.start()
 
     def _empty_queues(self):
-        while not self.task_queue.empty():
-            try:
-                self.task_queue.get(block=False)
-            except multiprocessing.queues.Empty:
-                break
+        '''Empty self.task_queue and self.result_queue until queue is empty'''
+        try:
+            while True:
+                self.task_queue.get_nowait()
+        except Empty:
+            pass
 
-        while not self.result_queue.empty():
-            try:
-                self.result_queue.get(block=False)
-            except multiprocessing.queues.Empty:
-                break
+        try:
+            while True:
+                self.result_queue.get_nowait()
+        except Empty:
+            pass
 
     def shutdown(self):
-        if self.running:
+        while self.running:
             log.debug('shutting down {!r}'.format(self))
+            self.shutdown_received.set()
             self._empty_queues()
 
             # Send shutdown signal
             for _i in range(self.n_workers):
-                self.task_queue.put(task_shutdown_sentinel, block=False)
+                self.task_queue.put_nowait(task_shutdown_sentinel)
 
             for worker in self.workers:
                 worker.join(self.shutdown_timeout)
                 if worker.is_alive():
                     log.debug('sending SIGINT to worker process {:d}'.format(worker.pid))
-                    os.kill(worker.pid, signal.SIGINT)
+                    worker.terminate()
                     worker.join(self.shutdown_timeout)
                     if worker.is_alive():
                         log.warning('sending SIGKILL to worker process {:d}'.format(worker.pid))
-                        os.kill(worker.pid, signal.SIGKILL)
+                        worker.kill()
                         worker.join()
 
                     log.debug('worker process {:d} terminated with code {:d}'.format(worker.pid, worker.exitcode))
@@ -180,4 +183,5 @@ class ProcessWorkManager(WorkManager):
 
             self._empty_queues()
             self.result_queue.put(result_shutdown_sentinel)
+
             self.running = False

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: westpa
-Version: 2022.8
+Version: 2022.10
 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
@@ -121,8 +121,8 @@ WESTPA is developed and tested on Unix-like operating systems, including Linux a
 
 Regardless of the chosen method of installation, before installing WESTPA, we recommend you to first install the Python 3 version provided by the latest free `Anaconda Python distribution`_. After installing Anaconda, create a new python environment for the WESTPA install with the following::
 
-    conda create -n westpa-2.0 python=3.9
-    conda activate westpa-2.0
+    conda create -n westpa python=3.11
+    conda activate westpa
 
 Then, we recommend installing WESTPA through conda or pip. Execute either of the following::
 
@@ -137,12 +137,12 @@ 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-main.tar.gz
+    tar xvzf westpa-2022.09.tar.gz
     cd westpa
     python -m pip install -e .
 
 .. _`releases page`: https://github.com/westpa/westpa/releases
-.. _`Anaconda Python distribution`: https://www.anaconda.com/products/individual
+.. _`Anaconda Python distribution`: https://www.anaconda.com/download
 .. _`wiki`: https://github.com/westpa/westpa/wiki/Installing-WESTPA
 
 ---------------

{westpa-2022.8.dist-info → westpa-2022.10.dist-info}/RECORD

@@ -1,6 +1,6 @@
-westpa/_version.py,sha256=ynQYEhRU4LpCFtVDYsxdHaJVVMjwxfKjIU7OxbyGJwA,499
+westpa/_version.py,sha256=59zLCh9LAH2F-_2LpdnyAOIoxNag6VO6D7dhZZILmMY,499
 westpa/__init__.py,sha256=xyNfYIcP2ncBLu_foO1NKmJrQh8-uYdwvMuM0HsOG1M,329
-westpa/fasthist/_fasthist.cpython-311-darwin.so,sha256=4qtQZmsMgBNNwegcsVOy47X8sh6yVk4cFhrZD6-zacc,268808
+westpa/fasthist/_fasthist.cpython-311-darwin.so,sha256=xxfTOjuXK4sKQas1xaWfK9fV8ddwxfO5GXoAZ41mfXg,246408
 westpa/fasthist/__init__.py,sha256=oWj0gKEkKfHjGHwkzmpgAxDz55h2ze_sqQVzWSsOP6s,1071
 westpa/fasthist/__main__.py,sha256=7XCBZvrKbBG3KEuQMpZD0jXa3vVMEVfZJTG8MmdbsrM,3902
 westpa/westext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -11,14 +11,14 @@ westpa/westext/weed/BinCluster.py,sha256=sx9xzZy_ot54TkFuBrCXzAtdAwT89TQEpj2cexx
 westpa/westext/weed/ProbAdjustEquil.py,sha256=eOs1lPB6hjBD44iU8KwVxR1OnaU7Kr0cuxuMVBA5PY0,4218
 westpa/westext/adaptvoronoi/adaptVor_driver.py,sha256=xZdBJo-VcX8USB-vpBZWh1qDCMwP-_GMl7V04zaxXN4,8827
 westpa/westext/adaptvoronoi/__init__.py,sha256=Zk7CiLsUJr3qZwZPKSqOBTOVV8uUvsMXkCbiTflMLHA,88
-westpa/westext/stringmethod/string_method.py,sha256=HEjrck6l_mNvbcY3ZbltmTp6guN2bw-ll1LqOxgW1RY,10344
+westpa/westext/stringmethod/string_method.py,sha256=C89D7LScQz7CZcB83kHEy3Cc8RagZNLt-rmd6yGq5WU,10415
 westpa/westext/stringmethod/string_driver.py,sha256=8z4pEuflwRx0mb-KaRaqEk98cYUd2cvjglXDp4BRNQQ,9369
 westpa/westext/stringmethod/__init__.py,sha256=1Nk3Uygs6GWr_FJbNH0Rss2DENurIm4WGx86V0qXxy8,310
 westpa/westext/stringmethod/fourier_fitting.py,sha256=499B3GdZ_pYuFP6kK7ICDnL8StMHSKgrjPX9Xyl1NL8,2256
 westpa/westext/wess/__init__.py,sha256=5nw6mcZx7eI4szw0v2q8XBusvb0Q2MUCgGKQUx2j0DE,153
 westpa/westext/wess/ProbAdjust.py,sha256=zc0H_SURBTgxvZFQCFrXeq_pHzRDAG-ejnD6WKQGt5o,3233
 westpa/westext/wess/wess_driver.py,sha256=3CvHfnfap3TAZGVZvkNODxozcIOEhaobn4YN_ZS-htY,8984
-westpa/westext/hamsm_restarting/restart_driver.py,sha256=dl9D3Bp9GuOZTSRx0KmAjkJqTlqLBlbLkaR_IltstDQ,50032
+westpa/westext/hamsm_restarting/restart_driver.py,sha256=c5D1I82NVo93_zPcGVtA12c2P10mK_NmkBx06upz-GU,50284
 westpa/westext/hamsm_restarting/__init__.py,sha256=0vhEngHBLOp89Mp1CVvt9BYDPosrc1nWGZVNicKFuf8,59
 westpa/westext/hamsm_restarting/example_overrides.py,sha256=3eDzKh_F0yNVm0lN4u0Pnrnj_WR9y4JDXa1-CU7qlbY,1065
 westpa/tools/binning.py,sha256=oFtc_ld8b9JJUYt-AEMe4Z1L8XJ48Lsr8Iw6nTYgGNs,20718
@@ -35,45 +35,45 @@ westpa/tools/iter_range.py,sha256=nVQIvqJ9oXOALyQIFsFp_UqMjW5BBQUd1ShZttb20xo,87
 westpa/core/systems.py,sha256=pb9YNFUcDhx3Fvhb0NcjlPCdhSUk41IhI0Sqdtr91q8,3693
 westpa/core/we_driver.py,sha256=uxPTAyhZG28EfBSjKdq1EcMNhcYrvGzVK6t5jYHyKSA,40688
 westpa/core/wm_ops.py,sha256=o_pc0BHpfCkbveTO5h76hxjXJpQgw1S-zIzVmM_u-Qc,1529
-westpa/core/_rc.py,sha256=x74n2f88SFP_It70SmxxpOdBnL6gpQk5ktbqsU6QvvA,24621
+westpa/core/_rc.py,sha256=yPdvgqZKRS10iOWTS_TYma7Y3sdKnCDDFw5AnQvog9s,25508
 westpa/core/textio.py,sha256=lqohyyyfMTkFvTdQ8V45yUpASiJsWTh42XAG15K63dA,2434
 westpa/core/extloader.py,sha256=yxyJN-lHo3Zjd6jS6_uhC1fIl52H-h8sbV9zYJfEWGg,2239
-westpa/core/sim_manager.py,sha256=-dbsf74Q6eSA9SZKUtcPYAekl6OSYKMTpB45VhVMcE0,37906
+westpa/core/sim_manager.py,sha256=eeCg5dALUyZ_Rm1eRRBSOpR_0UDBnyQlBvPkWY4IlzE,38653
 westpa/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-westpa/core/h5io.py,sha256=x-n0jgekFhIi1tD7Ob7u_WUmATsulnMXsOvHkdUTHVg,37011
+westpa/core/h5io.py,sha256=s3_Rt8ZjvCpumyDMKctQl406dmo8muRiHHd0L34Qtyk,37077
 westpa/core/trajectory.py,sha256=DL7rsowKxBc1jwT7FPZFlfCWKuwagttZxd3SPgxZKU0,10913
 westpa/core/segment.py,sha256=Gd_5htIZ6xKxxCms9XMtJncehGvMVxZeNdy4drxrnpc,4421
 westpa/core/progress.py,sha256=tEDDn-JPY6ZNzYqyrdgA7peo7pDu8kOMvqfyiHWUgps,6753
-westpa/core/data_manager.py,sha256=xeqt1MtjMGSRs7QN2zxRi0KrQ1cIV4L7JlOnBx-DEYE,71783
+westpa/core/data_manager.py,sha256=fHgdILXZoiDyrDv34DjZqS5YyqqG6bbnUBLouqYwOFQ,71924
 westpa/core/states.py,sha256=umsdgSrYjt2vjw-1kQeiILWmureOBmBaOgg0nQxUVmA,13318
 westpa/core/yamlcfg.py,sha256=B78OEr1n_sIkW6kDzl3FO63tiugaT-1VutAgLxU0i7A,12696
 westpa/core/kinetics/matrates.py,sha256=1sf7L6ojLE8yT2sFfgeB8eqgjMHdMK2O_Xgyz_RjCzc,5554
 westpa/core/kinetics/events.py,sha256=VqYBN5rVOf3hAYUA6xQ6UN7GP6tVgRFIoP69tfGhkTo,6511
 westpa/core/kinetics/__init__.py,sha256=djtiki7X5-IEzwjwswbdgrolwUIzVAHKxCiI5B3WH28,510
-westpa/core/kinetics/_kinetics.cpython-311-darwin.so,sha256=yYTqnN_kD4rQh9q2ltR5f37oHIvIC-VSzBES2SwEXH4,431408
+westpa/core/kinetics/_kinetics.cpython-311-darwin.so,sha256=pY8XITycgjA-tA9EZ9VS9GvSRLnL0ntTqsfjba6d8a8,387512
 westpa/core/kinetics/rate_averaging.py,sha256=gIKDXBAOSDI6KythepoC4QipUPksTRBc9zbM7DRtwo4,10300
 westpa/core/binning/binless_driver.py,sha256=T5qWpLnjxCS9RdKeWf7eVCC_s6TQFDENL7X3VG6JIYo,2231
 westpa/core/binning/mab_driver.py,sha256=azSqc9pqHk_zc1ptGNjXARDbK-UAnPVmCiYwebi5mPY,2223
-westpa/core/binning/_assign.cpython-311-darwin.so,sha256=FrtUK91d13RiOuUgwe-j83XO2WZA805wosT_29sUqME,293056
+westpa/core/binning/_assign.cpython-311-darwin.so,sha256=W-tc8fTncvcN1YvVjb2h_KG3TZMJs_62csr19qJEijg,264480
 westpa/core/binning/binless.py,sha256=Fb9TI5swQntzXjmlWFbYQ9yjzjLxDKNVVdmRxRqOnIY,4056
 westpa/core/binning/__init__.py,sha256=XmjBP6fg_id_vDELkcWW3u2GeuL5OPWblvX-kc7mINk,1297
-westpa/core/binning/mab_manager.py,sha256=PUSA9J-dzmQdWQ9h5DEB9Eed6GVETf1EE43r6AvZLwI,9617
+westpa/core/binning/mab_manager.py,sha256=-bb9CdSXrx6XV8NWHa6Q1CTWVaGa4coAZn_lDlvHCkM,9815
 westpa/core/binning/assign.py,sha256=e1YWyU3R12evLAoIWUrEvv3uvdKFo4u_mfKGDcK5AVU,18028
 westpa/core/binning/binless_manager.py,sha256=XgsLaYhknzWA9IHCqOvmnLXSgM303KnKOUjLe1NM0Zw,9414
-westpa/core/binning/mab.py,sha256=YgNWCistmKPFbQp9TpFgnpgGWc-HZTvSwB6ZugPS0Oo,11614
+westpa/core/binning/mab.py,sha256=X7L1jx--nNJTNA-PeJGDpwSa2PDMoMb4OtLpjffXQ4A,16046
 westpa/core/binning/bins.py,sha256=WDj7DNX3MTVkRvkgAooa9G8VThxw32uIfMTuk9sS194,1460
 westpa/core/reweight/matrix.py,sha256=219sRxkML1V9niPIndSoRvJAC0fUmpG0PLDKpmfWW-g,5509
 westpa/core/reweight/__init__.py,sha256=8goYojsHMcJCZblBC2sc2fcj-NUNVEstbSLswKNlVfg,284
-westpa/core/reweight/_reweight.cpython-311-darwin.so,sha256=xisaXsja3l_6VwN78wchnrxSoAUxkOLxF1NKj3PReyI,350032
+westpa/core/reweight/_reweight.cpython-311-darwin.so,sha256=vx_WN-ID46Bs1tyF4NZ5CWHliwM5tTdBI9jXZUL2wXU,303264
 westpa/core/propagators/__init__.py,sha256=rx_kkeg3Tbb_rI0uhLGCD3OwSYj9QuhxF8QGN3mILrg,2373
-westpa/core/propagators/executable.py,sha256=B9jU6RKkApr5cqH56n49IQ1i_cUcJUMfx6fmBZoWgPk,32071
+westpa/core/propagators/executable.py,sha256=6YuNMZ7if4jGtZ2OV0k_7jmBvtHFfdaIX-LLQJ_KIc8,32201
 westpa/analysis/__init__.py,sha256=CcmVPCB9OSEib0mJ4U-s9v3nrj4h-T_9AGApAbPnn8I,268
-westpa/analysis/core.py,sha256=P_m5-sU1RURAtWQVlV_Y2pgPvwUjyCqFS-E4O3fsD4E,22399
+westpa/analysis/core.py,sha256=rZ7xcrskpPwy2lrB27gXT4mSQRbqnPj9D8yA-Utve-M,22426
 westpa/analysis/statistics.py,sha256=M3Gj1bOiAu_SA4upR7gENYEOP2gnIEaSOZeGyoIxAc8,789
 westpa/analysis/trajectories.py,sha256=jyrbbKOVyZ3GjHQushDS_G8C4IRXlUmxa-WzmEEVGwc,12878
 westpa/mclib/__init__.py,sha256=NskP81wKw-tHTniyJ8QbgKAHah5JdpCrnPKJo1T-nLw,11513
 westpa/mclib/__main__.py,sha256=cKqfE9koMcrHkslEPpFISA4Eblwl0mllaxn7pFeyX1A,881
-westpa/mclib/_mclib.cpython-311-darwin.so,sha256=3rmp7AmrHQkUA_Yv21z8_1RKoCoP0sFdAapr5Hvhpt8,272456
+westpa/mclib/_mclib.cpython-311-darwin.so,sha256=2X97cU0ZN3L63HW27Ha2d1Jd8w2MKdRm1l9n8mTFtEw,246144
 westpa/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 westpa/cli/tools/w_direct.py,sha256=5Z9eQpvpKM-40XdiI0L3t0O3jpjMx7tk8ndYAaJxvrc,22361
 westpa/cli/tools/w_dumpsegs.py,sha256=uv0WxvKGauyW6VT3zGyALUXVqSXwDrhwbF3ZVSJV9Mo,3952
@@ -93,13 +93,13 @@ westpa/cli/tools/plothist.py,sha256=2jpAk_-T2XoWUExUyUNk0JOucPjQX51JxtntXRlQ54I,
 westpa/cli/tools/w_kinetics.py,sha256=ALx8t9GGARfdMxgkPEqQzWoRVQkqJneM4EZF2ur_oPk,3542
 westpa/cli/tools/w_fluxanl.py,sha256=a_swklwO2BGW4kwyJHz2RdKNyadfBQgV_wTTBcfS1XA,15564
 westpa/cli/tools/w_reweight.py,sha256=McIhF9qeqUbJ8SFbskw6fn8OtJ9zFLaDQSqLm8xWarY,33410
-westpa/cli/tools/w_pdist.py,sha256=eObPha2I-lFknrUna770i_OqYVIEQHs6ZnhXpLfyzow,20677
-westpa/cli/tools/w_ipa.py,sha256=8YQbk_hSsR_QI0rk3PUctGoKXgrbNhIDruYp_CLcGok,37462
+westpa/cli/tools/w_pdist.py,sha256=I7yGHMvmU--jjuZNMSxtTSR_vLVhYvhJpjluzcjPGaQ,20821
+westpa/cli/tools/w_ipa.py,sha256=4ToZGmZxw6PM635lVEVMTwI15VcKMSSy6b9CQHET3Rs,37482
 westpa/cli/tools/w_bins.py,sha256=e9YMvQoQ5jjzBK8zlZgXNDCDhFGMMKgb2b-UdyI_qgQ,6801
 westpa/cli/tools/w_stateprobs.py,sha256=fOaHZe7RYCNsIJmbXQqkdU6_cxqKcQLrKh2sxdaYvIQ,3872
 westpa/cli/tools/w_postanalysis_reweight.py,sha256=lFjSuBWZ-25AKwA6_ee168BfINjbnVmxPDxYKJHFUkw,1808
 westpa/cli/core/w_fork.py,sha256=UZVY6nUdMRRbKPfNFGAfEAu7tVhu7NewopPdQ0s8cz8,5693
-westpa/cli/core/w_states.py,sha256=doVARhxDh_trSs3xsP8q0_J9QOGhAWXOKmjH3MBEdQY,9441
+westpa/cli/core/w_states.py,sha256=Fkr0WdUut59vPtj0_TZWAmY5_qf5H_WsoiusO7Slz50,9433
 westpa/cli/core/w_run.py,sha256=9fLOJjCYQadB28gdsKwGxwjJtSB5u0DRITzAWmL3rJg,2159
 westpa/cli/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 westpa/cli/core/w_truncate.py,sha256=-CHFOBr4NAZwGQ8-O5F7B0dPowpnFpm-mF9Us1gBgfo,1654
@@ -107,7 +107,7 @@ westpa/cli/core/w_init.py,sha256=V_CvlAuq8flg-zUO01sbMGYkLqrEDD4DU9sV90bYFus,879
 westpa/cli/core/w_succ.py,sha256=ZK1MHHu7t53VdBrRgJUe7b1R8DnhMKPjHOqbbOjC_As,3074
 westpa/trajtree/__init__.py,sha256=K64Ok5bUP-fXo1H2rigJqxCnm-U23tJlRngNOnzR3gs,96
 westpa/trajtree/trajtree.py,sha256=sLf4kTi0QyvFdbSR__YcPwOR2wcOxtlkC4IPUFcq-9M,4497
-westpa/trajtree/_trajtree.cpython-311-darwin.so,sha256=eGHeJoq0xw7StCmzP25YHoYpT8_rXrNhjbD9lPXG1w8,154960
+westpa/trajtree/_trajtree.cpython-311-darwin.so,sha256=6gDd_uxe9JYOUfSpLCYCeQ3pkfXAahplN_lkRxEnfPg,131000
 westpa/oldtools/files.py,sha256=JmLtZqxD88cybEHcOU6kodAeOJYxylpYFl4OQqU13Hs,944
 westpa/oldtools/miscfn.py,sha256=595W28JazmiU9ioDgOKU9ZxtXJue_q-8WcpOKTgkikQ,909
 westpa/oldtools/__init__.py,sha256=rxAxsQNQMADy5j8xrqW_7Vk3D9ajM7lfDjHaKQHRDTI,62
@@ -131,7 +131,7 @@ westpa/oldtools/stats/accumulator.py,sha256=AZ1RshALSHjdhfDXidE5_yHaDEsdDXfSzsmo
 westpa/oldtools/stats/mcbs.py,sha256=yMgvdEu70j-h1_kTqYakypFV3s7AtWqJioWuy2bLUFI,3387
 westpa/work_managers/__init__.py,sha256=nHbI9PmRosOeZ11gCHIwpv9qwgXbwUnGt9vIZ0nLtOg,1670
 westpa/work_managers/core.py,sha256=NVe9XhcfizBzXjkymgeo0xLzNLP0tP6-VoTE0uxu91U,15061
-westpa/work_managers/processes.py,sha256=zcHKanvTYnCNuU46F4EpqaRdj1XjtCe6ltw3g3bqRhg,6770
+westpa/work_managers/processes.py,sha256=iZRaOW7DEuggDcb92D0goGAbLvYjkSwamdpADx2zooM,6960
 westpa/work_managers/threads.py,sha256=-Xktf-LPqVRf7sMW7Yqdc_ayO_4x_f0zA9iZS_G-fuI,2335
 westpa/work_managers/mpi.py,sha256=ArxswC1CMgBc5rZ1nr4cQQvwHlCWAcN-BkZt8ilhSgk,9511
 westpa/work_managers/serial.py,sha256=fo5Sql5wO4PdFy2VbcssWy0G459MJwKjRWkklK6nDxo,694
@@ -141,10 +141,10 @@ westpa/work_managers/zeromq/__init__.py,sha256=rrl4YbEaZr2AiEBTMlhvEFH83dBlAwWR_
 westpa/work_managers/zeromq/core.py,sha256=K3Iyrz5u2Dy-GgZFL3ZXDN2iaaLm7qL-A3cm4PdBiF8,22907
 westpa/work_managers/zeromq/work_manager.py,sha256=UB_WvnejDRVi1ZU2QWpP9uzhnccOH7b3qHgU-wSstTY,22425
 westpa/work_managers/zeromq/node.py,sha256=CeoJhXVqrZxrV3lMnDtm3LNkGFxjS4dr3E6wd7ZQRTE,4877
-westpa-2022.8.dist-info/RECORD,,
-westpa-2022.8.dist-info/LICENSE,sha256=I2wUldIRJmflTYUxmSiITSZEKvlovlMPrE3JU5IslkY,1074
-westpa-2022.8.dist-info/AUTHORS,sha256=YMi91-Fs-vFgZKUaItfh20uXthT9oe2Kq6CQXmqMGqg,671
-westpa-2022.8.dist-info/WHEEL,sha256=3Ij8bI-sb8yCMxXItr4MLlNoRGZb2WoUxQe9xIFR_DQ,111
-westpa-2022.8.dist-info/entry_points.txt,sha256=0Ym8meKTdYbUEMtUHF_4zaZP__4ldfFnoYXyYlKRB6s,1428
-westpa-2022.8.dist-info/top_level.txt,sha256=otaLnQtwo9jKCJmja4iOOsOVDThUvPfjJaeLrgGEhlE,7
-westpa-2022.8.dist-info/METADATA,sha256=mr5Ug2g18LvcWV8tCqcsU9e4990CspZUnMexqT9O5bE,7577
+westpa-2022.10.dist-info/RECORD,,
+westpa-2022.10.dist-info/LICENSE,sha256=I2wUldIRJmflTYUxmSiITSZEKvlovlMPrE3JU5IslkY,1074
+westpa-2022.10.dist-info/AUTHORS,sha256=YMi91-Fs-vFgZKUaItfh20uXthT9oe2Kq6CQXmqMGqg,671
+westpa-2022.10.dist-info/WHEEL,sha256=3Ij8bI-sb8yCMxXItr4MLlNoRGZb2WoUxQe9xIFR_DQ,111
+westpa-2022.10.dist-info/entry_points.txt,sha256=0Ym8meKTdYbUEMtUHF_4zaZP__4ldfFnoYXyYlKRB6s,1428
+westpa-2022.10.dist-info/top_level.txt,sha256=otaLnQtwo9jKCJmja4iOOsOVDThUvPfjJaeLrgGEhlE,7
+westpa-2022.10.dist-info/METADATA,sha256=17fr3iDNghuqnwUeEVWPaoG_OF-pta25C9bYblf8UiU,7563