diff --git a/.github/actions/run_tests/entrypoint.sh b/.github/actions/run_tests/entrypoint.sh
index 6c5da65ea2..bd2aa579dc 100644
--- a/.github/actions/run_tests/entrypoint.sh
+++ b/.github/actions/run_tests/entrypoint.sh
@@ -61,7 +61,7 @@ if [[ "$INPUT_CATEGORIES" == pytests* ]]; then
   for x in `cat $PYTESTS_GROUPS_FILEPATH`; do
     marker="${x//_or_/ or }"
     marker="${marker//not_/not }"
-    command+="/usr/local/conda/envs/${METPLUS_ENV_TAG}/bin/pytest -vv --cov=../../../metplus -m \"$marker\""
+    command+="/usr/local/conda/envs/${METPLUS_ENV_TAG}/bin/pytest -vv --cov=../../../metplus --cov-append -m \"$marker\""
     command+=";if [ \$? != 0 ]; then status=1; fi;"
   done
   command+="if [ \$status != 0 ]; then echo ERROR: Some pytests failed. Search for FAILED to review; false; fi"
diff --git a/internal/tests/pytests/util/config_metplus/test_config_metplus.py b/internal/tests/pytests/util/config_metplus/test_config_metplus.py
index 8dda66dea1..ca6daf44f6 100644
--- a/internal/tests/pytests/util/config_metplus/test_config_metplus.py
+++ b/internal/tests/pytests/util/config_metplus/test_config_metplus.py
@@ -162,8 +162,8 @@ def test_find_var_indices_fcst(metplus_config,
 )
 @pytest.mark.util
 def test_get_field_search_prefixes(data_type, met_tool, expected_out):
-    assert(config_metplus.get_field_search_prefixes(data_type,
-                                                    met_tool) == expected_out)
+    assert(config_metplus._get_field_search_prefixes(data_type,
+                                                     met_tool) == expected_out)
 
 
 # search prefixes are valid prefixes to append to field info variables
diff --git a/internal/tests/pytests/util/string_manip/test_util_string_manip.py b/internal/tests/pytests/util/string_manip/test_util_string_manip.py
index d53f19b469..38eb260440 100644
--- a/internal/tests/pytests/util/string_manip/test_util_string_manip.py
+++ b/internal/tests/pytests/util/string_manip/test_util_string_manip.py
@@ -8,6 +8,18 @@
 from metplus.util.string_manip import *
 from metplus.util.string_manip import _fix_list
 
+@pytest.mark.parametrize(
+    'template, expected_output', [
+        ('', ''),
+        ('{init?fmt=%Y%m%d}_i{init?fmt=%H%M}_m0_f*',
+         r'{init?fmt=%Y%m%d}_i{init?fmt=%H%M}_m0_f*'),
+        ('pgbf{lead?fmt=%HHH}.gfs.{init?fmt=%Y%m%d%H}',
+         r'pgbf.*\.gfs\.{init?fmt=%Y%m%d%H}'),
+    ]
+)
+@pytest.mark.util
+def test_template_to_regex(template, expected_output):
+    assert template_to_regex(template) == expected_output
 
 @pytest.mark.parametrize(
     'subset_definition, expected_result', [
diff --git a/internal/tests/pytests/wrappers/stat_analysis/test_stat_analysis.py b/internal/tests/pytests/wrappers/stat_analysis/test_stat_analysis.py
index 1ef38667f1..de609612ab 100644
--- a/internal/tests/pytests/wrappers/stat_analysis/test_stat_analysis.py
+++ b/internal/tests/pytests/wrappers/stat_analysis/test_stat_analysis.py
@@ -198,7 +198,7 @@ def test_valid_init_env_vars(metplus_config, config_overrides,
     runtime_settings_dict_list = wrapper._get_all_runtime_settings(time_input)
     assert runtime_settings_dict_list
 
-    first_runtime_only = [runtime_settings_dict_list[0]]
+    first_runtime_only = runtime_settings_dict_list[0]
     wrapper._run_stat_analysis_job(first_runtime_only)
     all_cmds = wrapper.all_commands
 
diff --git a/metplus/util/config_metplus.py b/metplus/util/config_metplus.py
index 988472d630..f90aeed939 100644
--- a/metplus/util/config_metplus.py
+++ b/metplus/util/config_metplus.py
@@ -160,7 +160,7 @@ def _parse_launch_args(args):
     bad = False
     for arg in args:
         m = re.match(r'''(?x)
-          (?P<section>[a-zA-Z][a-zA-Z0-9_]*)
+          (?P<section>[a-zA-Z]\w*)
            \.(?P<option>[^=]+)
            =(?P<value>.*)$''', arg)
         # check if argument is a explicit variable override
@@ -615,7 +615,7 @@ def check_default(self, sec, name, default):
         #  using a default value
         self.set(sec, name, default)
 
-    def getexe(self, exe_name):
+    def getexe(self, exe_name, default=None, morevars=None, taskvars=None):
         """! Wraps produtil exe with checks to see if option is set and if
             exe actually exists. Returns None if not found instead of exiting
         """
@@ -642,18 +642,16 @@ def getexe(self, exe_name):
         self.set('config', exe_name, full_exe_path)
         return full_exe_path
 
-    def getdir(self, dir_name, default=None, must_exist=False):
+    def getdir(self, name, default=None, must_exist=False):
         """! Wraps produtil getdir and reports an error if
          it is set to /path/to
          """
-        dir_path = self.getraw('config', dir_name, default=default)
-
+        dir_path = self.getraw('config', name, default=default)
         if '/path/to' in dir_path:
-            raise ValueError(f"{dir_name} cannot be set to "
-                             "or contain '/path/to'")
+            raise ValueError(f"{name} cannot be set to or contain '/path/to'")
 
         if '\n' in dir_path:
-            raise ValueError(f"Invalid value for [config] {dir_name} "
+            raise ValueError(f"Invalid value for [config] {name} "
                              f"({dir_path}). Hint: Check that next variable "
                              "in the config file does not start with a space")
 
@@ -918,114 +916,48 @@ def parse_var_list(config, time_info=None, data_type=None, met_tool=None,
     # validate configs again in case wrapper is not running from run_metplus
     # this does not need to be done if parsing a specific data type,
     # i.e. ENS or FCST
-    if data_type is None:
-        if not validate_field_info_configs(config)[0]:
-            return []
-    elif data_type == 'BOTH':
+    if data_type == 'BOTH':
         config.logger.error("Cannot request BOTH explicitly in parse_var_list")
         return []
-
-    # var_list is a list containing an list of dictionaries
-    var_list = []
+    if data_type is None and not validate_field_info_configs(config)[0]:
+        return []
 
     # if specific data type is requested, only get that type
-    if data_type:
-        data_types = [data_type]
     # otherwise get both FCST and OBS
-    else:
-        data_types = ['FCST', 'OBS']
+    data_types = [data_type] if data_type else ['FCST', 'OBS']
 
     # get indices of VAR<n> items for data type and/or met tool
-    indices = []
-    if met_tool:
-        indices = _find_var_name_indices(config, data_types, met_tool)
+    indices = _get_var_name_indices(config, data_types, met_tool)
     if not indices:
-        indices = _find_var_name_indices(config, data_types)
+        return []
+
+    # list of dictionaries that contain variable/field information
+    var_list = []
 
     # get config name prefixes for each data type to find
-    dt_search_prefixes = {}
-    for current_type in data_types:
-        # get list of variable prefixes to search
-        prefixes = get_field_search_prefixes(current_type, met_tool)
-        dt_search_prefixes[current_type] = prefixes
+    dt_search_prefixes = _get_all_field_search_prefixes(data_types, met_tool)
 
     # loop over all possible variables and add them to list
     for index in indices:
-        field_info_list = []
-        for current_type in data_types:
-            # get dictionary of existing config variables to use
-            search_prefixes = dt_search_prefixes[current_type]
-            field_configs = get_field_config_variables(config,
-                                                       index,
-                                                       search_prefixes)
-
-            field_info = _format_var_items(field_configs, time_info,
-                                           config.logger)
-            if not isinstance(field_info, dict):
-                config.logger.error(f'Could not process {current_type}_'
-                                    f'VAR{index} variables: {field_info}')
-                continue
-
-            field_info['data_type'] = current_type.lower()
-            field_info_list.append(field_info)
+        field_list = _get_field_list(index, data_types, dt_search_prefixes,
+                                     config, time_info)
 
         # check that all fields types were found
-        if not field_info_list or len(data_types) != len(field_info_list):
+        if not field_list or len(data_types) != len(field_list):
             continue
 
         # check if number of levels for each field type matches
-        n_levels = len(field_info_list[0]['levels'])
-        if len(data_types) > 1:
-            if n_levels != len(field_info_list[1]['levels']):
-                continue
+        n_levels = len(field_list[0]['levels'])
+        if (len(data_types) > 1 and
+                n_levels != len(field_list[1]['levels'])):
+            continue
 
         # if requested, put all field levels in a single item
         if levels_as_list:
-            var_dict = {}
-            for field_info in field_info_list:
-                current_type = field_info.get('data_type')
-                var_dict[f"{current_type}_name"] = field_info.get('name')
-                var_dict[f"{current_type}_level"] = field_info.get('levels')
-                var_dict[f"{current_type}_thresh"] = field_info.get('thresh')
-                var_dict[f"{current_type}_extra"] = field_info.get('extra')
-                var_dict[f"{current_type}_output_name"] = field_info.get('output_names')
-
-            var_dict['index'] = index
-            var_list.append(var_dict)
+            var_list.append(_get_field_all_levels(index, field_list))
             continue
 
-        # loop over levels and add all values to output dictionary
-        for level_index in range(n_levels):
-            var_dict = {}
-
-            # get level values to use for string substitution in name
-            # used for python embedding calls that read the level value
-            sub_info = {}
-            for field_info in field_info_list:
-                dt_level = f"{field_info.get('data_type')}_level"
-                sub_info[dt_level] = field_info.get('levels')[level_index]
-
-            for field_info in field_info_list:
-                current_type = field_info.get('data_type')
-                name = field_info.get('name')
-                level = field_info.get('levels')[level_index]
-                thresh = field_info.get('thresh')
-                extra = field_info.get('extra')
-                output_name = field_info.get('output_names')[level_index]
-
-                # substitute level in name if filename template is specified
-                subbed_name = do_string_sub(name,
-                                            skip_missing_tags=True,
-                                            **sub_info)
-
-                var_dict[f"{current_type}_name"] = subbed_name
-                var_dict[f"{current_type}_level"] = level
-                var_dict[f"{current_type}_thresh"] = thresh
-                var_dict[f"{current_type}_extra"] = extra
-                var_dict[f"{current_type}_output_name"] = output_name
-
-            var_dict['index'] = index
-            var_list.append(var_dict)
+        var_list.extend(_get_field_each_level(index, n_levels, field_list))
 
     # extra debugging information used for developer debugging only
     '''
@@ -1062,6 +994,31 @@ def parse_var_list(config, time_info=None, data_type=None, met_tool=None,
     return sorted(var_list, key=lambda x: x['index'])
 
 
+def _get_var_name_indices(config, data_types, met_tool):
+    """!Get list of indices of field variables from config.
+    Look for wrapper-specific first. If no indices are found, look for generic
+    variables.
+
+    @param config METplusConfig object to parse
+    @param data_types list of prefixes of config variables that describe the
+     type of data e.g. FCST or OBS.
+    @param met_tool name of wrapper to search for wrapper-specific
+    variables, e.g. *_GRID_STAT_VAR<n>_*.
+    @returns list of integers for all matching config variables
+    """
+    indices = []
+
+    # look for wrapper-specific variables first
+    if met_tool:
+        indices = _find_var_name_indices(config, data_types, met_tool)
+
+    # if no wrapper-specific variables are found, look for generic variables
+    if not indices:
+        indices = _find_var_name_indices(config, data_types)
+
+    return indices
+
+
 def _find_var_name_indices(config, data_types, met_tool=None):
     """!Get list of indices used in _VAR<n>_ config variables. Data type
     determines prefix of variable name to find. If FCST or OBS is included
@@ -1099,6 +1056,104 @@ def _find_var_name_indices(config, data_types, met_tool=None):
     return [int(index) for index in indices]
 
 
+def _get_field_list(index, data_types, dt_search_prefixes, config, time_info):
+    """!Get list of field information.
+
+    @param index integer index for fields to search
+    @param data_types list of prefixes of config variables that describe the
+     type of data e.g. FCST or OBS
+    @param dt_search_prefixes dictionary of search strings to find variables
+    @param config METplusConfig object to query
+    @param time_info dictionary containing time info for current run
+    @returns list of dictionaries that contain field information
+    """
+    field_list = []
+    for current_type in data_types:
+        # get dictionary of existing config variables to use
+        search_prefixes = dt_search_prefixes[current_type]
+        field_configs = get_field_config_variables(config, index,
+                                                   search_prefixes)
+        field_info = _format_var_items(field_configs, time_info,
+                                       config.logger)
+        if not isinstance(field_info, dict):
+            config.logger.error(f'Could not process {current_type}_'
+                                f'VAR{index} variables: {field_info}')
+            continue
+
+        field_info['data_type'] = current_type.lower()
+        field_list.append(field_info)
+
+    return field_list
+
+
+def _get_field_all_levels(index, field_list):
+    """!Create dictionary of field information with all levels contained as a
+    list in a single item.
+
+    @param index integer index for fields to search
+    @param field_list list of dictionaries that contain field information
+    @returns dictionary containing field information with data type in keys
+    """
+    var_dict = {}
+    for field in field_list:
+        current_type = field.get('data_type')
+        var_dict[f"{current_type}_name"] = field.get('name')
+        var_dict[f"{current_type}_level"] = field.get('levels')
+        var_dict[f"{current_type}_thresh"] = field.get('thresh')
+        var_dict[f"{current_type}_extra"] = field.get('extra')
+        var_dict[f"{current_type}_output_name"] = field.get('output_names')
+
+    var_dict['index'] = index
+    return var_dict
+
+
+def _get_field_each_level(index, n_levels, field_list):
+    """!Create list of dictionaries of field information with a separate entry
+    for each level value, creating a list of name/level pairs.
+
+    @param index integer index for fields to search
+    @param n_levels integer number of levels to read
+    @param field_list list of dictionaries that contain field information
+    @returns list of dictionaries containing field information with
+     data type in keys
+    """
+    new_var_list = []
+    # loop over levels and add all values to output dictionary
+    for level_index in range(n_levels):
+        var_dict = {}
+
+        # get level values to use for string substitution in name
+        # used for python embedding calls that read the level value
+        sub_info = {}
+        for field_info in field_list:
+            dt_level = f"{field_info.get('data_type')}_level"
+            sub_info[dt_level] = field_info.get('levels')[level_index]
+
+        for field_info in field_list:
+            current_type = field_info.get('data_type')
+            name = field_info.get('name')
+            level = field_info.get('levels')[level_index]
+            thresh = field_info.get('thresh')
+            extra = field_info.get('extra')
+            output_name = field_info.get('output_names')[level_index]
+
+            # substitute level in name if filename template is specified
+            subbed_name = do_string_sub(name,
+                                        skip_missing_tags=True,
+                                        **sub_info)
+
+            var_dict[f"{current_type}_name"] = subbed_name
+            var_dict[f"{current_type}_level"] = level
+            var_dict[f"{current_type}_thresh"] = thresh
+            var_dict[f"{current_type}_extra"] = extra
+            var_dict[f"{current_type}_output_name"] = output_name
+
+        var_dict['index'] = index
+        new_var_list.append(var_dict)
+
+    return new_var_list
+
+
 def _format_var_items(field_configs, time_info=None, logger=None):
     """! Substitute time information into field information and format values.
 
@@ -1107,8 +1162,8 @@ def _format_var_items(field_configs, time_info=None, logger=None):
         @param logger (optional) logging object
         @returns dictionary containing name, levels, and output_names, as
          well as thresholds and extra options if found. If not enough
-         information was set in the METplusConfig object, an empty
-         dictionary is returned.
+         information was set in the METplusConfig object, a string describing
+         the error is returned
     """
     # dictionary to hold field (var) item info
     var_items = {}
@@ -1165,6 +1220,18 @@ def _format_var_items(field_configs, time_info=None, logger=None):
         extra_list = list(filter(None, extra_list))
         var_items['extra'] = f"{'; '.join(extra_list)};"
 
+    _get_output_names(field_configs, var_items, time_info)
+
+    if len(var_items['levels']) != len(var_items['output_names']):
+        return 'Number of levels does not match number of output names'
+
+    return var_items
+
+
+def _get_output_names(field_configs, var_items, time_info):
+    """!Read output names from field config and set in var_items. If output
+    names are not set, use input names.
+    """
     # get output names if they are set
     out_name_str = field_configs.get('output_names')
 
@@ -1172,20 +1239,34 @@ def _format_var_items(field_configs, time_info=None, logger=None):
     if not out_name_str:
         for _ in var_items['levels']:
             var_items['output_names'].append(var_items['name'])
-    else:
-        for out_name in getlist(out_name_str):
-            if time_info:
-                out_name = do_string_sub(out_name,
-                                         **time_info)
-            var_items['output_names'].append(out_name)
+        return
 
-    if len(var_items['levels']) != len(var_items['output_names']):
-        return 'Number of levels does not match number of output names'
+    for out_name in getlist(out_name_str):
+        if time_info:
+            out_name = do_string_sub(out_name,
+                                     **time_info)
+        var_items['output_names'].append(out_name)
 
-    return var_items
+
+def _get_all_field_search_prefixes(data_types, met_tool):
+    """!Populate dictionary with prefixes to search for config variables.
+
+    @param data_types list of field types to search, i.e. FCST, OBS, ENS, etc.
+    @param met_tool name of tool to search for variable or None if looking
+     for generic field info
+    @returns dictionary where keys are a data type and value is a list of
+     search prefixes
+    """
+    dt_search_prefixes = {}
+    for current_type in data_types:
+        # get list of variable prefixes to search
+        prefixes = _get_field_search_prefixes(current_type, met_tool)
+        dt_search_prefixes[current_type] = prefixes
+
+    return dt_search_prefixes
 
 
-def get_field_search_prefixes(data_type, met_tool=None):
+def _get_field_search_prefixes(data_type, met_tool=None):
     """! Get list of prefixes to search for field variables.
 
         @param data_type type of field to search for, i.e. FCST, OBS, ENS, etc.
diff --git a/metplus/util/config_validate.py b/metplus/util/config_validate.py
index e005763150..d282f11d21 100644
--- a/metplus/util/config_validate.py
+++ b/metplus/util/config_validate.py
@@ -69,11 +69,9 @@ def check_for_deprecated_config(config):
 
         # check if <n> is found in old item, use regex to find vars if found
         if '<n>' not in old:
-            upgrade_note = handle_deprecated(old, depr_info.get('alt', ''),
-                                             depr_info, config, all_sed_cmds,
-                                             e_list)
-            if upgrade_note:
-                upgrade_notes.add(upgrade_note)
+            handle_deprecated(old, depr_info.get('alt', ''),
+                              depr_info, config, all_sed_cmds,
+                              e_list, upgrade_notes)
             continue
 
         old_regex = old.replace('<n>', r'(\d+)')
@@ -84,11 +82,9 @@ def check_for_deprecated_config(config):
             old_with_index = old.replace('<n>', index)
             alt_with_index = depr_info.get('alt', '').replace('<n>', index)
 
-            upgrade_note = handle_deprecated(old_with_index, alt_with_index,
-                                             depr_info, config, all_sed_cmds,
-                                             e_list)
-            if upgrade_note:
-                upgrade_notes.add(upgrade_note)
+            handle_deprecated(old_with_index, alt_with_index,
+                              depr_info, config, all_sed_cmds,
+                              e_list, upgrade_notes)
 
     if 'ensemble' in upgrade_notes:
         short_msg = ('Please navigate to the upgrade instructions: '
@@ -102,42 +98,39 @@ def check_for_deprecated_config(config):
         e_list.append(short_msg)
 
     # if any errors exist, report them and exit
-    if e_list:
-        logger.error('DEPRECATED CONFIG ITEMS WERE FOUND. PLEASE FOLLOW THE '
-                     'INSTRUCTIONS TO UPDATE THE CONFIG FILES')
-        for error_msg in e_list:
-            logger.error(error_msg)
-        return False, all_sed_cmds
-
-    return True, []
-
+    if not e_list:
+        return True, []
 
-def handle_deprecated(old, alt, depr_info, config, all_sed_cmds, e_list):
-    sec = 'config'
-    config_files = config.getstr('config', 'CONFIG_INPUT', '').split(',')
+    logger.error('DEPRECATED CONFIG ITEMS WERE FOUND. PLEASE FOLLOW THE '
+                 'INSTRUCTIONS TO UPDATE THE CONFIG FILES')
+    for error_msg in e_list:
+        logger.error(error_msg)
+    return False, all_sed_cmds
 
-    upgrade_note = None
 
+def handle_deprecated(old, alt, depr_info, config, all_sed_cmds, e_list,
+                      upgrade_notes):
     # if deprecated config item is found
-    if not config.has_option(sec, old):
-        return upgrade_note
+    if not config.has_option('config', old):
+        return
 
     upgrade_note = depr_info.get('upgrade')
+    if upgrade_note:
+        upgrade_notes.add(upgrade_note)
 
     # if it is required to remove, add to error list
     if not alt:
         e_list.append("{} should be removed".format(old))
-        return upgrade_note
+        return
 
     e_list.append("{} should be replaced with {}".format(old, alt))
 
+    config_files = config.getstr('config', 'CONFIG_INPUT', '').split(',')
     if 'copy' not in depr_info.keys() or depr_info['copy']:
         for config_file in config_files:
             all_sed_cmds.append(f"sed -i 's|^{old}|{alt}|g' {config_file}")
             all_sed_cmds.append(f"sed -i 's|{{{old}}}|{{{alt}}}|g' {config_file}")
 
-    return upgrade_note
-
 
 def check_for_deprecated_met_config(config):
     sed_cmds = []
@@ -227,32 +220,45 @@ def validate_field_info_configs(config):
         # get other data type
         for index, data_type_list in data_types_and_indices.items():
 
-            is_valid, err_msgs, sed_cmds = is_var_item_valid(data_type_list, index, ext, config)
+            is_valid, err_msgs, sed_cmds = is_var_item_valid(data_type_list,
+                                                             index, ext,
+                                                             config)
             if not is_valid:
-                for err_msg in err_msgs:
-                    config.logger.error(err_msg)
+                [config.logger.error(err_msg) for err_msg in err_msgs]
                 all_sed_cmds.extend(sed_cmds)
                 all_good = False
+                continue
 
-            # make sure FCST and OBS have the same number of levels if coming from separate variables
-            elif ext == 'LEVELS' and all(item in ['FCST', 'OBS'] for item in data_type_list):
-                fcst_levels = getlist(config.getraw('config', f"FCST_VAR{index}_LEVELS", ''))
+            if not _check_levels(config, index, ext, data_type_list):
+                all_good = False
 
-                # add empty string if no levels are found because python embedding items do not need
-                # to include a level, but the other item may have a level and the numbers need to match
-                if not fcst_levels:
-                    fcst_levels.append('')
+    return all_good, all_sed_cmds
 
-                obs_levels = getlist(config.getraw('config', f"OBS_VAR{index}_LEVELS", ''))
-                if not obs_levels:
-                    obs_levels.append('')
 
-                if len(fcst_levels) != len(obs_levels):
-                    config.logger.error(f"FCST_VAR{index}_LEVELS and OBS_VAR{index}_LEVELS do not have "
-                                        "the same number of elements")
-                    all_good = False
+def _check_levels(config, index, ext, data_type_list):
+    # make sure FCST/OBS have the same num levels if coming from separate vars
+    if ext != 'LEVELS' or not all(
+            item in ['FCST', 'OBS'] for item in data_type_list):
+        return True
 
-    return all_good, all_sed_cmds
+    fcst_levels = getlist(
+        config.getraw('config', f"FCST_VAR{index}_LEVELS", ''))
+
+    # add empty string if no levels are found because python embedding items do not need
+    # to include a level, but the other item may have a level and the numbers need to match
+    if not fcst_levels:
+        fcst_levels.append('')
+
+    obs_levels = getlist(config.getraw('config', f"OBS_VAR{index}_LEVELS", ''))
+    if not obs_levels:
+        obs_levels.append('')
+
+    if len(fcst_levels) != len(obs_levels):
+        config.logger.error(
+            f"FCST_VAR{index}_LEVELS and OBS_VAR{index}_LEVELS do not have "
+            "the same number of elements")
+        return False
+    return True
 
 
 def skip_field_info_validation(config):
@@ -315,37 +321,38 @@ def is_var_item_valid(item_list, index, ext, config):
     elif 'FCST' in item_list and 'OBS' not in item_list:
         # if FCST level has 1 item and OBS name is a python embedding script,
         # don't report error
-        level_list = getlist(config.getraw('config',
-                                           f'FCST_VAR{index}_LEVELS',
-                                           ''))
-        other_name = config.getraw('config', f'OBS_VAR{index}_NAME', '')
-        skip_error_for_py_embed = ext == 'LEVELS' and is_python_script(other_name) and len(level_list) == 1
-        # do not report error for OPTIONS since it isn't required to be the same length
-        if ext not in ['OPTIONS'] and not skip_error_for_py_embed:
-            msg.append(f"If FCST{full_ext} is set, you must either set OBS{full_ext} or "
-                       f"change FCST{full_ext} to BOTH{full_ext}")
-
-            config_files = config.getstr('config', 'CONFIG_INPUT', '').split(',')
-            for config_file in config_files:
-                sed_cmds.append(f"sed -i 's|^FCST{full_ext}|BOTH{full_ext}|g' {config_file}")
-                sed_cmds.append(f"sed -i 's|{{FCST{full_ext}}}|{{BOTH{full_ext}}}|g' {config_file}")
+        _fcst_or_obs_missing('FCST', config, index, ext, sed_cmds, msg)
 
     elif 'OBS' in item_list and 'FCST' not in item_list:
         # if OBS level has 1 item and FCST name is a python embedding script,
         # don't report error
-        level_list = getlist(config.getraw('config',
-                                           f'OBS_VAR{index}_LEVELS',
-                                           ''))
-        other_name = config.getraw('config', f'FCST_VAR{index}_NAME', '')
-        skip_error_for_py_embed = ext == 'LEVELS' and is_python_script(other_name) and len(level_list) == 1
+        _fcst_or_obs_missing('OBS', config, index, ext, sed_cmds, msg)
+
+    return not bool(msg), msg, sed_cmds
+
 
-        if ext not in ['OPTIONS'] and not skip_error_for_py_embed:
-            msg.append(f"If OBS{full_ext} is set, you must either set FCST{full_ext} or "
-                          f"change OBS{full_ext} to BOTH{full_ext}")
+def _fcst_or_obs_missing(found_item, config, index, ext, sed_cmds, msg):
+    other_item = 'OBS' if found_item == 'FCST' else 'FCST'
+    full_ext = f"_VAR{index}_{ext}"
+    # if FCST level has 1 item and OBS name is a python embedding script,
+    # don't report error
+    level_list = getlist(config.getraw('config',
+                                       f'{found_item}_VAR{index}_LEVELS',
+                                       ''))
+    other_name = config.getraw('config', f'{other_item}_VAR{index}_NAME', '')
+    skip_error_for_py_embed = (ext == 'LEVELS' and is_python_script(other_name)
+                               and len(level_list) == 1)
+    # do not report error for OPTIONS since it isn't required to be same length
+    if ext in ['OPTIONS'] or skip_error_for_py_embed:
+        return
 
-            config_files = config.getstr('config', 'CONFIG_INPUT', '').split(',')
-            for config_file in config_files:
-                sed_cmds.append(f"sed -i 's|^OBS{full_ext}|BOTH{full_ext}|g' {config_file}")
-                sed_cmds.append(f"sed -i 's|{{OBS{full_ext}}}|{{BOTH{full_ext}}}|g' {config_file}")
+    msg.append(
+        f"If {found_item}{full_ext} is set, you must either set {other_item}{full_ext} or "
+        f"change {found_item}{full_ext} to BOTH{full_ext}")
 
-    return not bool(msg), msg, sed_cmds
+    config_files = config.getstr('config', 'CONFIG_INPUT', '').split(',')
+    for config_file in config_files:
+        sed_cmds.append(
+            f"sed -i 's|^{found_item}{full_ext}|BOTH{full_ext}|g' {config_file}")
+        sed_cmds.append(
+            f"sed -i 's|{{{found_item}{full_ext}}}|{{BOTH{full_ext}}}|g' {config_file}")
diff --git a/metplus/util/diff_util.py b/metplus/util/diff_util.py
old mode 100644
new mode 100755
diff --git a/metplus/util/doc_util.py b/metplus/util/doc_util.py
index be0c043cf1..05b8269494 100755
--- a/metplus/util/doc_util.py
+++ b/metplus/util/doc_util.py
@@ -1,5 +1,12 @@
 #! /usr/bin/env python3
 
+"""
+Program Name: doc_util.py
+Contact(s): George McCabe
+Description: METplus utility that generates instructions to help developers
+ add new support for setting MET configuration variables through the wrappers.
+"""
+
 import sys
 import os
 
@@ -9,6 +16,16 @@
     sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
     from string_manip import get_wrapper_name
 
+SCRIPT_INFO_TEXT = (
+    'This script is intended to help developers add support for setting '
+    'MET configuration variables from a METplus wrapper.\n\n'
+    'WARNING: Guidance output from this script may differ slightly '
+    'from the actual steps to take. The text that is generated should be '
+    'reviewed for accuracy before adding to codebase.\n\n'
+    'NOTE: Text between lines that contain all dashes (-) should be '
+    'added or replaced in the files. Do not include the dash lines.'
+)
+
 
 def print_doc_text(tool_name, input_dict):
     """! Format documentation for adding support for a new MET config variable
@@ -19,64 +36,67 @@ def print_doc_text(tool_name, input_dict):
      @param dict_items (optional) list of MET dictionary var items if met_var
       is a dictionary
     """
-    wrapper_caps = tool_name.upper()
-    wrapper_camel = get_wrapper_name(wrapper_caps)
+    _print_script_info_text()
+
+    wrapper_camel = get_wrapper_name(tool_name)
 
     # get info for each variable and store it in a dictionary
-    met_vars = []
-    for var_name, dict_list in input_dict.items():
-        metplus_var = f'{wrapper_caps}_{var_name.upper()}'
-        env_var_name = f'METPLUS_{var_name.upper()}'
-        met_var = {'name': var_name, 'dict_items': dict_list,
-                   'metplus_config_names': [], 'met_config_names': []}
-        if not dict_list:
-            met_var['env_var_name'] = env_var_name
-            met_var['metplus_config_names'].append(metplus_var)
-            met_var['met_config_names'].append(var_name)
-        else:
-            met_var['env_var_name'] = f'{env_var_name}_DICT'
-            for item_name in dict_list:
-                metplus_config = f'{metplus_var}_{item_name.upper()}'
-                met_config = f"{var_name}.{item_name}"
-                met_var['metplus_config_names'].append(metplus_config)
-                met_var['met_config_names'].append(met_config)
+    met_vars = _get_met_vars(tool_name, input_dict)
 
-        met_vars.append(met_var)
+    _step_add_wrapper_env_var_keys(met_vars, tool_name)
+    _step_add_wrapper_config_dict(met_vars, tool_name)
+
+    _step_add_parm_metplus_config(met_vars, wrapper_camel)
+    _step_add_parm_met_config(met_vars, wrapper_camel)
+
+    _step_add_doc_metplus_config(met_vars, wrapper_camel)
+    _step_add_doc_met_config(met_vars, wrapper_camel)
+    _step_add_doc_glossary(met_vars, wrapper_camel)
+    _step_add_unit_tests(tool_name, met_vars)
+    _step_test_met_tool(wrapper_camel)
+
+    _print_script_end_text()
+
+
+def _print_script_info_text():
+    _print_divider_line(after=False)
+    print(f'Running script: {__file__}')
+    _print_divider_line(before=False)
+    print(SCRIPT_INFO_TEXT)
 
-    print(f"\nWrapper: {wrapper_camel}\n")
-    for index, var in enumerate(met_vars, 1):
-        print(f"MET Variable {index}: {var['name']}")
-        if var['dict_items']:
-            print(f"  Dictionary Items: {', '.join(var['dict_items'])}")
-        print()
 
-    print('\nWARNING: Guidance output from this script may differ slightly '
-          'from the actual steps to take. It is intended to assist the process.'
-          ' The text that is generated should be reviewed for accuracy before '
-          'adding to codebase.')
+def _print_script_end_text():
+    _print_divider_line(after=False)
+    print('END OF SCRIPT')
+    _print_divider_line(before=False)
 
-    print("\nNOTE: Text between lines that contain all dashes (-) should be "
-          "added or replaced in the files. Do not include the dash lines.")
-    print('\n==================================================\n')
+
+def _step_add_wrapper_env_var_keys(met_vars, tool_name):
+    _print_divider_line()
     print(f'In metplus/wrappers/{tool_name}_wrapper.py\n\n'
-          f'In the {wrapper_camel}Wrapper '
+          f'In the {get_wrapper_name(tool_name)}Wrapper '
           f'class, add the following to the WRAPPER_ENV_VAR_KEYS class '
-          f"variable list:\n"
-          "\n---------------------------------------------")
+          f"variable list:\n")
+    _print_divider_line(char='-', after=False)
     for var in met_vars:
         print(f"        '{var['env_var_name']}',")
-    print(f"---------------------------------------------\n")
+    _print_divider_line(char='-', before=False)
+
 
-    print('\n==================================================\n')
-    print(f'In metplus/wrappers/{tool_name}_wrapper.py\n\n')
-    print(f'In the create_c_dict function for {wrapper_camel}Wrapper, add a '
+def _step_add_wrapper_config_dict(met_vars, tool_name):
+    _print_divider_line()
+    print(f'In metplus/wrappers/{tool_name}_wrapper.py\n')
+    print(f'In the create_c_dict function for '
+          f'{get_wrapper_name(tool_name)}Wrapper, add a '
           'function call to read the new METplus config variables and save '
           'the value to be added to the wrapped MET config file.\n')
-    print("\n---------------------------------------------")
+
+    _print_divider_line(char='-', after=False)
     for var in met_vars:
-        print_add_met_config(var)
-    print("---------------------------------------------\n"
-          "\nwhere DATA_TYPE can be string, list, int, float, bool, "
+        _print_add_met_config(var)
+    _print_divider_line(char='-', before=False)
+
+    print("where DATA_TYPE can be string, list, int, float, bool, "
           "or thresh. Refer to the METplus Contributor's Guide "
           "Basic Components section to see how to add additional info.\n")
     print("Sometimes a function is written to handle MET config dictionary"
@@ -84,20 +104,25 @@ def print_doc_text(tool_name, input_dict):
           " Search for functions that start with handle_ in "
           "CommandBuilder or other parent class wrappers to see if a "
           "function already exists for the item you are adding or to use "
-          "as an example to write a new one.\n\n")
+          "as an example to write a new one.")
+
 
-    print('\n==================================================\n')
-    print('Add the new variables to the basic use case example for the tool,\n'
-          f'i.e. parm/use_cases/met_tool_wrapper/{wrapper_camel}/'
-          f'{wrapper_camel}.conf:\n'
-          "\n---------------------------------------------")
+def _step_add_parm_metplus_config(met_vars, wrapper_camel):
+    _print_divider_line()
+    print(f'In parm/use_cases/met_tool_wrapper/{wrapper_camel}/{wrapper_camel}.conf')
+    print('\nAdd the new variables commented out in the basic use case')
+
+    _print_divider_line(char='-', after=False)
 
     for var in met_vars:
         for mp_config in var['metplus_config_names']:
             print(f'#{mp_config} =')
 
-    print("---------------------------------------------\n")
-    print('\n\n==================================================\n')
+    _print_divider_line(char='-', before=False)
+
+
+def _step_add_parm_met_config(met_vars, wrapper_camel):
+    _print_divider_line()
 
     var_names = '/'.join([var['name'] for var in met_vars])
     print(f"In parm/met_config/{wrapper_camel}Config_wrapped\n\n"
@@ -109,47 +134,51 @@ def print_doc_text(tool_name, input_dict):
           "config files so that they produce the same output.\n\n")
 
     for var in met_vars:
-        print("REPLACE:\n"
-              "\n---------------------------------------------")
-        print(f"{var['name']} = ..."
-              "\n---------------------------------------------\n"
-              "\nwith:\n"
-              "\n---------------------------------------------\n"
-              f"//{var['name']} ="
-              f"{' {' if var['dict_items'] else ''}\n${{{var['env_var_name']}}}"
-              "\n---------------------------------------------\n")
-
-    print('\n==================================================\n')
-    print(f"\nIn docs/Users_Guide/wrappers.rst\n\n"
-          f"Under {wrapper_camel} => "
-          "METplus Configuration section, add:\n"
-          "\n---------------------------------------------")
-
+        print("REPLACE:")
+        _print_divider_line(char='-', after=False)
+        print(f"{var['name']} = ...")
+        _print_divider_line(char='-', before=False)
+        print('with:')
+        _print_divider_line(char='-', after=False)
+        print(f"//{var['name']} ={' {' if var['dict_items'] else ''}")
+        print(f"${{{var['env_var_name']}}}")
+        _print_divider_line(char='-', before=False)
+
+
+def _step_add_doc_metplus_config(met_vars, wrapper_camel):
+    _print_divider_line()
+    print(f"In docs/Users_Guide/wrappers.rst\n\n"
+          f"Under {wrapper_camel} => METplus Configuration section, add:")
+
+    _print_divider_line(char='-', after=False)
     for var in met_vars:
         for metplus_config_name in var['metplus_config_names']:
             print(f'| :term:`{metplus_config_name}`')
+    _print_divider_line(char='-', before=False)
 
-    print("---------------------------------------------\n")
-    print('\n==================================================\n')
-    print(f"\n\nIn docs/Users_Guide/wrappers.rst\n\n"
-          f"Under {wrapper_camel} => "
-          "MET Configuration section, add:\n"
-          "\n---------------------------------------------\n")
 
+def _step_add_doc_met_config(met_vars, wrapper_camel):
+    _print_divider_line()
+    print(f"In docs/Users_Guide/wrappers.rst\n\n"
+          f"Under {wrapper_camel} => MET Configuration section, add:")
+    _print_divider_line(char='-')
     for var in met_vars:
-        print_met_config_table(var)
+        _print_met_config_table(var)
+    _print_divider_line(char='-', before=False)
 
-    print("---------------------------------------------")
-    print('\n==================================================\n')
-    print(f"In docs/Users_Guide/glossary.rst"
-          "\n\nAdd the following anywhere in the file:\n")
-    print("---------------------------------------------\n")
 
+def _step_add_doc_glossary(met_vars, wrapper_camel):
+    _print_divider_line()
+    print("In docs/Users_Guide/glossary.rst\n\n"
+          "Add the following anywhere in the file:")
+    _print_divider_line(char='-')
     for var in met_vars:
-        print_glossary_entry(var, wrapper_camel)
+        _print_glossary_entry(var, wrapper_camel)
+    _print_divider_line(char='-', before=False)
 
-    print("---------------------------------------------")
-    print('\n==================================================\n')
+
+def _step_add_unit_tests(tool_name, met_vars):
+    _print_divider_line()
     print(f"In internal/tests/pytests/wrappers/{tool_name}/"
           f"test_{tool_name}_wrapper.py"
           "\n\nAdd the following items to "
@@ -157,15 +186,18 @@ def print_doc_text(tool_name, input_dict):
           "if the tool does not have unit tests to check the handling of "
           "MET config variables, you will need to add those tests. See "
           "grid_stat/test_grid_stat_wrapper.py for an example. Change "
-          "VALUE to an appropriate value for the variable.\n\n")
+          "VALUE to an appropriate value for the variable.\n")
 
-    print("---------------------------------------------")
+    _print_divider_line(char='-', after=False)
     for var in met_vars:
-        print_unit_test(var)
-    print("---------------------------------------------")
+        _print_unit_test(var)
+    _print_divider_line(char='-', before=False)
+
+
+def _step_test_met_tool(wrapper_camel):
     # add note to test setting a valid value in the basic use case config file
     # to ensure that it is formatted properly when read by the MET tool
-    print('\n==================================================\n')
+    _print_divider_line()
     print(f"In parm/use_cases/met_tool_wrapper/{wrapper_camel}"
           "\n\nVerify that the new METplus configuration variable(s) "
           "will be formatted properly when read by the MET tool by "
@@ -175,9 +207,50 @@ def print_doc_text(tool_name, input_dict):
           "Be sure to remove the value and comment out the variable "
           "after you have confirmed this step.")
 
-    print('\n==================================================\n')
 
-def print_add_met_config(var):
+def _get_met_vars(tool_name, input_dict):
+    met_vars = []
+    for var_name, dict_list in input_dict.items():
+        metplus_var = f'{tool_name.upper()}_{var_name.upper()}'
+        env_var_name = f'METPLUS_{var_name.upper()}'
+        met_var = {'name': var_name, 'dict_items': dict_list,
+                   'metplus_config_names': [], 'met_config_names': []}
+        if not dict_list:
+            met_var['env_var_name'] = env_var_name
+            met_var['metplus_config_names'].append(metplus_var)
+            met_var['met_config_names'].append(var_name)
+        else:
+            met_var['env_var_name'] = f'{env_var_name}_DICT'
+            for item_name in dict_list:
+                metplus_config = f'{metplus_var}_{item_name.upper()}'
+                met_config = f"{var_name}.{item_name}"
+                met_var['metplus_config_names'].append(metplus_config)
+                met_var['met_config_names'].append(met_config)
+
+        met_vars.append(met_var)
+
+    _print_divider_line()
+    print('Generating instructions for adding support for:\n')
+    print(f"Wrapper: {get_wrapper_name(tool_name)}\n")
+    for index, var in enumerate(met_vars, 1):
+        print(f"MET Variable {index}: {var['name']}")
+        if var['dict_items']:
+            print(f"  Dictionary Items: {', '.join(var['dict_items'])}")
+        print()
+
+    return met_vars
+
+
+def _print_divider_line(char='=', count=80, before=True, after=True):
+    value = char * count
+    if before:
+        value = f'\n{value}'
+    if after:
+        value = f'{value}\n'
+    print(value)
+
+
+def _print_add_met_config(var):
     met_var = var['name']
     dict_items = var['dict_items']
     if not dict_items:
@@ -190,7 +263,8 @@ def print_add_met_config(var):
         print("        })")
     print()
 
-def print_met_config_table(var):
+
+def _print_met_config_table(var):
     env_var_name = var['env_var_name']
     metplus_names = var['metplus_config_names']
     met_names = var['met_config_names']
@@ -209,7 +283,8 @@ def print_met_config_table(var):
                             )
     print(list_table_text)
 
-def print_glossary_entry(var, wrapper_camel):
+
+def _print_glossary_entry(var, wrapper_camel):
     metplus_names = var['metplus_config_names']
     met_names = var['met_config_names']
     for metplus_config_name, met_config_name in zip(metplus_names, met_names):
@@ -221,14 +296,13 @@ def print_glossary_entry(var, wrapper_camel):
         )
         print(f'{glossary_entry}\n')
 
-def print_unit_test(var):
+
+def _print_unit_test(var):
     input_dict_items = []
     output_items = []
     metplus_names = var['metplus_config_names']
     met_names = var['met_config_names']
     dict_items = var['dict_items']
-    env_var_name = var['env_var_name']
-    var_name = var['name']
     for metplus_config_name, met_config_name in zip(metplus_names, met_names):
         if dict_items:
             item_name = met_config_name.split('.')[1]
@@ -244,19 +318,21 @@ def print_unit_test(var):
             output_fmt = output_item
 
         test_text = (f"        ({{{mp_config_dict_item} }},\n"
-                     f"         {{'{env_var_name}': '{var_name} = "
+                     f"         {{'{var['env_var_name']}': '{var['name']} = "
                      f"{output_fmt}'}}),\n")
         print(test_text)
 
-    if dict_items:
-        all_items_text = "        ({\n"
-        for input_dict_item in input_dict_items:
-            all_items_text += f"           {input_dict_item}\n"
-        all_items_text += ("          },\n"
-                           f"         {{'{env_var_name}': '{var_name} = {{")
-        all_items_text += ''.join(output_items)
-        all_items_text += "}'}),"
-        print(all_items_text)
+    if not dict_items:
+        return
+    all_items_text = "        ({\n"
+    for input_dict_item in input_dict_items:
+        all_items_text += f"           {input_dict_item}\n"
+    all_items_text += (
+        f"          }},\n         {{'{var['env_var_name']}': '{var['name']} = {{"
+    )
+    all_items_text += ''.join(output_items)
+    all_items_text += "}'}),"
+    print(all_items_text)
 
 
 def doc_util_usage():
@@ -272,6 +348,7 @@ def doc_util_usage():
           'output_prefix \n  (both of the variables from the previous '
           'examples)\n')
 
+
 if __name__ == "__main__":
     # sys.argv[1] is MET tool name, i.e. grid_stat
     # sys.argv[2+] is MET variable name, i.e. output_flag or a MET variable
@@ -280,10 +357,10 @@ def doc_util_usage():
         doc_util_usage()
         sys.exit(1)
 
-    tool_name = sys.argv[1]
-    input_dict = {}
+    TOOL_NAME = sys.argv[1]
+    INPUT_DICT = {}
     for arg in sys.argv[2:]:
-        var_name, *dict_items = arg.split()
-        input_dict[var_name] = dict_items
+        variable_name, *dictionary_items = arg.split()
+        INPUT_DICT[variable_name] = dictionary_items
 
-    print_doc_text(tool_name, input_dict)
+    print_doc_text(TOOL_NAME, INPUT_DICT)
diff --git a/metplus/util/field_util.py b/metplus/util/field_util.py
index 1f1457a03f..ee0d07c0cf 100644
--- a/metplus/util/field_util.py
+++ b/metplus/util/field_util.py
@@ -6,6 +6,7 @@
 
 from . import get_threshold_via_regex, is_python_script, remove_quotes
 
+
 def field_read_prob_info(config, c_dict, data_types, app_name):
     """! Read probabilistic variables for each field data type from the config
          object and sets values in the c_dict as appropriate.
@@ -53,60 +54,21 @@ def get_field_info(c_dict, data_type='', v_name='', v_level='', v_thresh=None,
           field info string. If False, add single quotes around each
           field info string (defaults to True)
          @rtype string
-         @return Returns a list of formatted field information or a string
-          containing an error message if something went wrong
+         @return list of formatted field information
     """
-    # if thresholds are set
-    if v_thresh:
-        # if neither fcst or obs are probabilistic,
-        # pass in all thresholds as a comma-separated list for 1 field info
-        if (not c_dict.get('FCST_IS_PROB', False) and
-                not c_dict.get('OBS_IS_PROB', False)):
-            thresholds = [','.join(v_thresh)]
-        else:
-            thresholds = v_thresh
-    # if no thresholds are specified, fail if prob field is in grib PDS
-    elif (c_dict.get(f'{data_type}_IS_PROB', False) and
-          c_dict.get(f'{data_type}_PROB_IN_GRIB_PDS', False) and
-          not is_python_script(v_name)):
-        return 'No threshold was specified for probabilistic GRIB data'
-    else:
-        thresholds = [None]
+    thresholds = _get_thresholds(c_dict, v_thresh, v_name, data_type)
 
     # list to hold field information
     fields = []
 
     for thresh in thresholds:
-        if (c_dict.get(f'{data_type}_PROB_IN_GRIB_PDS', False) and
-                not is_python_script(v_name)):
-            field = _handle_grib_pds_field_info(v_name, v_level, thresh)
-        else:
-            # add field name
-            field = f'name="{v_name}";'
-
-            if v_level:
-                field += f' level="{remove_quotes(v_level)}";'
-
-            if c_dict.get(f'{data_type}_IS_PROB', False):
-                field += " prob=TRUE;"
-
-        # handle cat_thresh
-        if c_dict.get(f'{data_type}_IS_PROB', False):
-            # add probabilistic cat thresh if different from default ==0.1
-            cat_thresh = c_dict.get(f'{data_type}_PROB_THRESH')
-        else:
-            cat_thresh = thresh
+        field = _get_name_and_level(c_dict, data_type, v_name, v_level, thresh)
 
-        if cat_thresh:
-            field += f" cat_thresh=[ {cat_thresh} ];"
+        # handle cat_thresh if set
+        field += _get_thresh(c_dict, data_type, thresh)
 
         # handle extra options if set
-        if v_extra:
-            extra = v_extra.strip()
-            # if trailing semi-colon is not found, add it
-            if not extra.endswith(';'):
-                extra = f"{extra};"
-            field += f' {extra}'
+        field += _get_extra(v_extra)
 
         # add curly braces around field info if requested
         # otherwise add single quotes around field info
@@ -119,6 +81,91 @@ def get_field_info(c_dict, data_type='', v_name='', v_level='', v_thresh=None,
     return fields
 
 
+def _get_thresholds(c_dict, v_thresh, v_name, data_type):
+    # if thresholds are set
+    if v_thresh:
+        # if neither fcst or obs are probabilistic,
+        # pass in all thresholds as a comma-separated list for 1 field info
+        if (not c_dict.get('FCST_IS_PROB', False) and
+                not c_dict.get('OBS_IS_PROB', False)):
+            return [','.join(v_thresh)]
+
+        return v_thresh
+
+    # if no thresholds are specified, fail if prob field is in grib PDS
+    if (c_dict.get(f'{data_type}_IS_PROB', False) and
+            c_dict.get(f'{data_type}_PROB_IN_GRIB_PDS', False) and
+            not is_python_script(v_name)):
+        return 'No threshold was specified for probabilistic GRIB data'
+
+    return [None]
+
+
+def _get_name_and_level(c_dict, data_type, name, level, thresh):
+    """!Format the name and level of a field to what the MET tools expect.
+
+    @param c_dict config dictionary to read values
+    @param data_type type of data to find i.e. FCST or OBS
+    @param name variable name
+    @param level variable level if set
+    @param thresh variable threshold if set
+    @returns string with the formatted name and level information
+    """
+    if (c_dict.get(f'{data_type}_PROB_IN_GRIB_PDS', False) and
+            not is_python_script(name)):
+        return _handle_grib_pds_field_info(name, level, thresh)
+
+    # add field name
+    field = f'name="{name}";'
+
+    # add level if set
+    if level:
+        field += f' level="{remove_quotes(level)}";'
+
+    # add probabilistic identifier if necessary
+    if c_dict.get(f'{data_type}_IS_PROB', False):
+        field += " prob=TRUE;"
+
+    return field
+
+
+def _get_thresh(c_dict, data_type, thresh):
+    """!Format the categorical threshold value to what MET tools expect if set.
+
+    @param c_dict config dictionary to read values
+    @param data_type type of data to find i.e. FCST or OBS
+    @param thresh variable threshold if set
+    @returns formatted threshold key/value or empty string if not set
+    """
+    cat_thresh = thresh
+    if c_dict.get(f'{data_type}_IS_PROB', False):
+        # add probabilistic cat thresh if different from default ==0.1
+        cat_thresh = c_dict.get(f'{data_type}_PROB_THRESH')
+
+    if not cat_thresh:
+        return ''
+
+    return f" cat_thresh=[ {cat_thresh} ];"
+
+
+def _get_extra(v_extra):
+    """!Format extra field options to what MET tools expect if set. Adds
+    trailing semicolon if not found.
+
+    @param v_extra string with extra variable config options
+    @returns string with a blank space followed by additional field options
+     if set or empty string if not.
+    """
+    if not v_extra:
+        return ''
+
+    extra = v_extra.strip()
+    # if trailing semi-colon is not found, add it
+    if not extra.endswith(';'):
+        extra = f"{extra};"
+    return f' {extra}'
+
+
 def format_field_info(c_dict, var_info, data_type, add_curly_braces=True):
     """! Format field information into format expected by MET config file
 
@@ -144,6 +191,18 @@ def format_field_info(c_dict, var_info, data_type, add_curly_braces=True):
 
 
 def format_all_field_info(c_dict, var_list, data_type, add_curly_braces=True):
+    """!Format field information for a list of fields.
+
+         @param c_dict config dictionary to read values
+         @param var_list list of dictionaries of field info to format
+         @param data_type type of data to find i.e. FCST or OBS
+         @param add_curly_braces if True, add curly braces around each
+          field info string. If False, add single quotes around each
+          field info string (defaults to True)
+         @rtype string
+         @return Returns a string of formatted field information separated by
+         comma or None if something went wrong
+    """
     formatted_list = []
     for var_info in var_list:
         field_info = format_field_info(c_dict=c_dict,
diff --git a/metplus/util/met_config.py b/metplus/util/met_config.py
index fcebe2ec63..7cf33564e1 100644
--- a/metplus/util/met_config.py
+++ b/metplus/util/met_config.py
@@ -105,10 +105,9 @@ def children(self, children):
         if not children and 'dict' in self.data_type:
             raise TypeError("Must have children if data_type is dict.")
 
-        if children:
-            if 'dict' not in self.data_type:
-                raise TypeError("data_type must be dict to have "
-                                f"children. data_type is {self.data_type}")
+        if children and 'dict' not in self.data_type:
+            raise TypeError("data_type must be dict to have "
+                            f"children. data_type is {self.data_type}")
 
         self._children = children
 
@@ -341,7 +340,6 @@ def add_met_config_dict_list(config, app_name, output_dict, dict_name,
 
             if not add_met_config_item(config, item, met_config_items):
                 is_ok = False
-                continue
 
         dict_string = format_met_config('dict',
                                         met_config_items,
@@ -449,26 +447,32 @@ def _get_config_or_default(mp_config_name, get_function,
 
 def set_met_config_list(config, c_dict, mp_config, met_config_name,
                         c_dict_key=None, **kwargs):
-    """! Get list from METplus configuration file and format it to be passed
-          into a MET configuration file. Set c_dict item with formatted string.
-         Args:
-             @param c_dict configuration dictionary to set
-             @param mp_config_name METplus configuration variable name. Assumed to be
-              in the [config] section. Value can be a comma-separated list of items.
-             @param met_config name of MET configuration variable to set. Also used
-              to determine the key in c_dict to set (upper-case)
-             @param c_dict_key optional argument to specify c_dict key to store result. If
-              set to None (default) then use upper-case of met_config_name
-             @param allow_empty if True, if METplus config variable is set
-              but is an empty string, then set the c_dict value to an empty
-              list. If False, behavior is the same as when the variable is
-              not set at all, which is to not set anything for the c_dict
-              value
-             @param remove_quotes if True, output value without quotes.
-              Default value is False
-             @param default (Optional) if set, use this value as default
-              if config is not set
+    """!Get list from METplus configuration file and format it to be passed
+     into a MET configuration file. Set c_dict item with formatted string.
+
+    @param config METplusConfig to read values from
+    @param c_dict configuration dictionary to set
+    @param mp_config_name METplus configuration variable name. Assumed to be
+     in the [config] section. Value can be a comma-separated list of items.
+    @param met_config name of MET configuration variable to set. Also used
+     to determine the key in c_dict to set (upper-case)
+    @param c_dict_key optional argument to specify c_dict key to store result.
+     If set to None (default) then use upper-case of met_config_name
+    @param allow_empty if True, if METplus config variable is set
+     but is an empty string, then set the c_dict value to an empty
+     list. If False, behavior is the same as when the variable is
+     not set at all, which is to not set anything for the c_dict
+     value
+    @param remove_quotes if True, output value without quotes.
+     Default value is False
+    @param default (Optional) if set, use this value as default
+     if config is not set
+    @returns False if there was an error trying to read/set the value or True
+    if everything ran fine even if no value was set
     """
+    if c_dict is None:
+        return False
+
     mp_config_name = config.get_mp_config_name(mp_config)
     conf_value = _get_config_or_default(
         mp_config_name,
@@ -480,57 +484,64 @@ def set_met_config_list(config, c_dict, mp_config, met_config_name,
 
     # convert value from config to a list
     conf_values = getlist(conf_value)
-    if conf_values or kwargs.get('allow_empty', False):
-        out_values = []
-        for conf_value in conf_values:
-            remove_quotes = kwargs.get('remove_quotes', False)
-            # if not removing quotes, escape any quotes found in list items
-            if not remove_quotes:
-                conf_value = conf_value.replace('"', '\\"')
 
-            conf_value = util_remove_quotes(conf_value)
-            if not remove_quotes:
-                conf_value = f'"{conf_value}"'
+    # if no values are found and the value cannot be set to an empty list
+    # e.g. the MET default is non-empty, return without setting anything
+    if not conf_values and not kwargs.get('allow_empty', False):
+        return True
 
-            if kwargs.get('uppercase', False):
-                conf_value = conf_value.upper()
+    out_values = []
+    for conf_value in conf_values:
+        remove_quotes = kwargs.get('remove_quotes', False)
+        # if not removing quotes, escape any quotes found in list items
+        if not remove_quotes:
+            conf_value = conf_value.replace('"', '\\"')
 
-            out_values.append(conf_value)
-        out_value = f"[{', '.join(out_values)}]"
+        conf_value = util_remove_quotes(conf_value)
+        if not remove_quotes:
+            conf_value = f'"{conf_value}"'
 
-        if not c_dict_key:
-            c_key = met_config_name.upper()
-        else:
-            c_key = c_dict_key
+        if kwargs.get('uppercase', False):
+            conf_value = conf_value.upper()
 
-        if met_config_name:
-            out_value = f'{met_config_name} = {out_value};'
-        c_dict[c_key] = out_value
+        out_values.append(conf_value)
+    out_value = f"[{', '.join(out_values)}]"
+
+    if met_config_name:
+        out_value = f'{met_config_name} = {out_value};'
+
+    c_key = c_dict_key if c_dict_key else met_config_name.upper()
+    c_dict[c_key] = out_value
 
     return True
 
 
 def set_met_config_string(config, c_dict, mp_config, met_config_name,
                           c_dict_key=None, **kwargs):
-    """! Get string from METplus configuration file and format it to be passed
-          into a MET configuration file. Set c_dict item with formatted string.
-
-             @param c_dict configuration dictionary to set
-             @param mp_config METplus configuration variable name. Assumed to be
-              in the [config] section. Value can be a comma-separated list of items.
-             @param met_config_name name of MET configuration variable to set. Also used
-              to determine the key in c_dict to set (upper-case)
-             @param c_dict_key optional argument to specify c_dict key to store result. If
-              set to None (default) then use upper-case of met_config_name
-             @param remove_quotes if True, output value without quotes.
-              Default value is False
-             @param to_grid if True, format to_grid value
-              Default value is False
-             @param default (Optional) if set, use this value as default
-              if config is not set
-             @param add_x if True, add (x) to variable name, e.g. convert(x)
-              Default value is False
+    """!Get string from METplus configuration file and format it to be passed
+     into a MET configuration file. Set c_dict item with formatted string.
+
+    @param c_dict configuration dictionary to set
+    @param mp_config METplus configuration variable name. Assumed to be
+     in the [config] section. Value can be a comma-separated list of items.
+    @param met_config_name name of MET configuration variable to set. Also used
+     to determine the key in c_dict to set (upper-case)
+    @param c_dict_key optional argument to specify c_dict key to store result. If
+     set to None (default) then use upper-case of met_config_name
+    @param remove_quotes if True, output value without quotes.
+     Default value is False
+    @param to_grid if True, format to_grid value
+     Default value is False
+    @param default (Optional) if set, use this value as default
+     if config is not set
+    @param add_x if True, add (x) to variable name, e.g. convert(x)
+     Default value is False
+    @returns False if there was an error trying to read/set the value or True
+    if everything ran fine even if no value was set
     """
+    if c_dict is None:
+        return False
+
     mp_config_name = config.get_mp_config_name(mp_config)
     conf_value = _get_config_or_default(
         mp_config_name,
@@ -551,19 +562,20 @@ def set_met_config_string(config, c_dict, mp_config, met_config_name,
     if kwargs.get('to_grid', False):
         conf_value = format_regrid_to_grid(conf_value)
 
-    c_key = c_dict_key if c_dict_key else met_config_name.upper()
     if met_config_name:
         config_name = met_config_name
         if kwargs.get('add_x'):
             config_name = f'{config_name}(x)'
         conf_value = f'{config_name} = {conf_value};'
 
+    c_key = c_dict_key if c_dict_key else met_config_name.upper()
     c_dict[c_key] = conf_value
+
     return True
 
 
 def set_met_config_number(config, c_dict, num_type, mp_config,
-                          met_config_name, c_dict_key=None, **kwargs):
+                          met_config_name, c_dict_key=None):
     """! Get integer from METplus configuration file and format it to be passed
           into a MET configuration file. Set c_dict item with formatted string.
 
@@ -607,25 +619,23 @@ def set_met_config_number(config, c_dict, num_type, mp_config,
 
 
 def set_met_config_int(config, c_dict, mp_config_name, met_config_name,
-                       c_dict_key=None, **kwargs):
+                       c_dict_key=None):
     return set_met_config_number(config, c_dict, 'int',
                                  mp_config_name,
                                  met_config_name,
-                                 c_dict_key=c_dict_key,
-                                 **kwargs)
+                                 c_dict_key=c_dict_key)
 
 
 def set_met_config_float(config, c_dict, mp_config_name,
-                         met_config_name, c_dict_key=None, **kwargs):
+                         met_config_name, c_dict_key=None):
     return set_met_config_number(config, c_dict, 'float',
                                  mp_config_name,
                                  met_config_name,
-                                 c_dict_key=c_dict_key,
-                                 **kwargs)
+                                 c_dict_key=c_dict_key)
 
 
 def set_met_config_thresh(config, c_dict, mp_config, met_config_name,
-                          c_dict_key=None, **kwargs):
+                          c_dict_key=None):
     mp_config_name = config.get_mp_config_name(mp_config)
     if mp_config_name is None:
         return True
diff --git a/metplus/util/run_util.py b/metplus/util/run_util.py
index 9a98f91098..efe2ecd57b 100644
--- a/metplus/util/run_util.py
+++ b/metplus/util/run_util.py
@@ -91,52 +91,33 @@ def pre_run_setup(config_inputs):
 
 
 def run_metplus(config):
-    total_errors = 0
-
+    """!Load all wrapper instances, check for initialization errors, run all
+    wrappers, write list of commands to file if any were executed, check
+    for wrapper runtime errors.
+
+    @param config METplusConfig object to parse process list, pass to wrapper
+    constructors, and log any messages.
+    @returns integer number of errors that occurred
+    """
     # Use config object to get the list of processes to call
     process_list = get_process_list(config)
 
     try:
-        processes = []
-        for process, instance in process_list:
-            try:
-                logname = f"{process}.{instance}" if instance else process
-                logger = config.log(logname)
-                package_name = ('metplus.wrappers.'
-                                f'{camel_to_underscore(process)}_wrapper')
-                module = import_module(package_name)
-                command_builder = (
-                    getattr(module, f"{process}Wrapper")(config,
-                                                         instance=instance)
-                )
-
-                # if Usage specified in PROCESS_LIST, print usage and exit
-                if process == 'Usage':
-                    command_builder.run_all_times()
-                    return 0
-            except AttributeError:
-                logger.error("There was a problem loading "
-                             f"{process} wrapper.")
-                return 1
-            except ModuleNotFoundError:
-                logger.error(f"Could not load {process} wrapper. "
-                             "Wrapper may have been disabled.")
-                return 1
-
-            processes.append(command_builder)
+        # if Usage is in process list, run it and exit
+        if 'Usage' in process_list:
+            wrapper = _get_wrapper_instance(config, 'Usage')
+            wrapper.run_all_times()
+            return 0
+
+        # get all wrapper instances
+        processes = _load_all_wrappers(config, process_list)
+        if not processes:
+            return 1
 
         # check if all processes initialized correctly
-        allOK = True
-        for process in processes:
-            if not process.isOK:
-                allOK = False
-                class_name = process.__class__.__name__.replace('Wrapper', '')
-                logger.error("{} was not initialized properly".format(class_name))
-
-        # exit if any wrappers did not initialized properly
-        if not allOK:
-            logger.info("Refer to ERROR messages above to resolve issues.")
-            return 1
+        init_errors = _check_wrapper_init_errors(processes, config.logger)
+        if init_errors:
+            return init_errors
 
         all_commands = []
         for process in processes:
@@ -144,31 +125,114 @@ def run_metplus(config):
             if new_commands:
                 all_commands.extend(new_commands)
 
-        # if process list contains any wrapper that should run commands
-        if any([item[0] not in NO_COMMAND_WRAPPERS for item in process_list]):
-            # write out all commands and environment variables to file
-            write_all_commands(all_commands, config)
+        # write out all commands and environment variables to file
+        write_all_commands(all_commands, config)
 
         # compute total number of errors that occurred and output results
-        for process in processes:
-            if not process.errors:
-                continue
-            process_name = process.__class__.__name__.replace('Wrapper', '')
-            error_msg = f'{process_name} had {process.errors} error'
-            if process.errors > 1:
-                error_msg += 's'
-            error_msg += '.'
-            logger.error(error_msg)
-            total_errors += process.errors
-
-        return total_errors
-    except:
-        logger.exception("Fatal error occurred")
-        logger.info("Check the log file for more information: "
-                    f"{get_logfile_info(config)}")
+        return _check_wrapper_run_errors(processes, config.logger)
+    except Exception:
+        config.logger.exception("Fatal error occurred")
+        config.logger.info("Check the log file for more information: "
+                           f"{get_logfile_info(config)}")
         return 1
 
 
+def _get_wrapper_instance(config, process, instance=None):
+    """!Initialize METplus wrapper instance.
+
+    @param config METplusConfig object to pass to wrapper constructor
+    @param process name of wrapper in camel case, e.g. GridStat
+    @param instance (optional) instance identifier for creating multiple
+    instances of a wrapper. Set to None (default) if no instance is specified
+    @returns CommandBuilder sub-class object or None if something went wrong
+    """
+    try:
+        package_name = ('metplus.wrappers.'
+                        f'{camel_to_underscore(process)}_wrapper')
+        module = import_module(package_name)
+        metplus_wrapper = (
+            getattr(module, f"{process}Wrapper")(config, instance=instance)
+        )
+    except AttributeError:
+        config.logger.error(f"There was a problem loading {process} wrapper.")
+        return None
+    except ModuleNotFoundError:
+        config.logger.error(f"Could not load {process} wrapper. "
+                            "Wrapper may have been disabled.")
+        return None
+
+    return metplus_wrapper
+
+
+def _load_all_wrappers(config, process_list):
+    """!Initialize all METplus wrapper instances in process list.
+
+    @param config METplusConfig object to pass to wrapper constructors
+    @param process_list list of tuple containing process name and instance
+    identifier if specified.
+    @returns list of wrapper instances if all were loaded properly, or None
+    if something went wrong.
+    """
+    processes = []
+    is_ok = True
+    for process, instance in process_list:
+        wrapper = _get_wrapper_instance(config, process, instance)
+        if not wrapper:
+            is_ok = False
+            continue
+        processes.append(wrapper)
+
+    return processes if is_ok else None
+
+
+def _check_wrapper_init_errors(processes, logger=None):
+    """!Check all wrappers for initialization errors.
+
+    @param processes list of wrapper to check
+    @param logger (optional) log object to write logs
+    @returns integer number of initialization errors from all wrappers
+    """
+    all_ok = True
+    errors = 0
+    for process in processes:
+        if process.isOK:
+            continue
+        all_ok = False
+        errors += process.errors
+        if logger:
+            class_name = process.__class__.__name__.replace('Wrapper', '')
+            logger.error("{} was not initialized properly".format(class_name))
+
+    # if any wrappers did not initialize properly
+    if not all_ok:
+        if logger:
+            logger.info("Refer to ERROR messages above to resolve issues.")
+        # set number of errors to 1 if no errors were set by wrapper
+        if not errors:
+            errors = 1
+
+    return errors
+
+
+def _check_wrapper_run_errors(processes, logger=None):
+    total_errors = 0
+    for process in processes:
+        if not process.errors:
+            continue
+        total_errors += process.errors
+
+        if not logger:
+            continue
+        process_name = process.__class__.__name__.replace('Wrapper', '')
+        error_msg = f'{process_name} had {process.errors} error'
+        if process.errors > 1:
+            error_msg += 's'
+        error_msg += '.'
+        logger.error(error_msg)
+
+    return total_errors
+
+
 def post_run_cleanup(config, app_name, total_errors):
     logger = config.logger
     # scrub staging directory if requested
diff --git a/metplus/util/string_manip.py b/metplus/util/string_manip.py
index fd523c6ce2..8fcfeab8dd 100644
--- a/metplus/util/string_manip.py
+++ b/metplus/util/string_manip.py
@@ -399,13 +399,20 @@ def round_0p5(val):
 
 def generate_tmp_filename():
     random_string = ''.join(random.choice(string.ascii_letters)
-                            for i in range(10))
+                            for _ in range(10))
     return f"metplus_tmp_{random_string}"
 
 
 def template_to_regex(template):
-    in_template = re.sub(r'\.', '\\.', template)
-    return re.sub(r'{lead.*?}', '.*', in_template)
+    """!Convert path with filename template tags for regular expression by
+    escaping '.' character with a backslash and replacing any lead template
+    tags with a wildcard regular expression.
+
+    @param template string to convert
+    @returns formatted string
+    """
+    in_template = template.replace('.', r'\.')
+    return re.sub(r'{lead[^}]*}', '.*', in_template)
 
 
 def split_level(level):
@@ -459,9 +466,9 @@ def expand_int_string_to_list(int_string):
     # if string ends with +, remove it and add it back at the end
     if int_string.strip().endswith('+'):
         int_string = int_string.strip(' +')
-        hasPlus = True
+        has_plus = True
     else:
-        hasPlus = False
+        has_plus = False
 
     # separate into list by comma
     comma_list = int_string.split(',')
@@ -476,7 +483,7 @@ def expand_int_string_to_list(int_string):
         else:
             subset_list.append(int(comma_item.strip()))
 
-    if hasPlus:
+    if has_plus:
         subset_list.append('+')
 
     return subset_list
diff --git a/metplus/util/string_template_substitution.py b/metplus/util/string_template_substitution.py
index b5d1b9e4df..d181332b9f 100644
--- a/metplus/util/string_template_substitution.py
+++ b/metplus/util/string_template_substitution.py
@@ -18,7 +18,7 @@
 from dateutil.relativedelta import relativedelta
 
 from . import time_util
-from .constants import *
+from .constants import COMPRESSION_EXTENSIONS
 
 TEMPLATE_IDENTIFIER_BEGIN = "{"
 TEMPLATE_IDENTIFIER_END = "}"
@@ -348,7 +348,7 @@ def do_string_sub(tmpl,
     # find inner most tags between nested curly braces
     # match_list is a list with the contents being the data between the
     # curly braces
-    match_list = re.findall(r'\{([^}{]*)\}', tmpl)
+    match_list = re.findall(r'\{([^}{]*)}', tmpl)
 
     if len(match_list) == 0:
         return tmpl
@@ -486,8 +486,8 @@ def populate_match_dict(template, filepath, logger=None):
     all_tags = match.group(2)
 
     # check if text before and after tags matches template and strip off from file path
-    filepath = check_pre_text(filepath, match.group(1), logger)
-    filepath = check_post_text(filepath, match.group(3), logger)
+    filepath = _check_pre_text(filepath, match.group(1))
+    filepath = _check_post_text(filepath, match.group(3))
     if filepath is None:
         return None, None
 
@@ -535,13 +535,13 @@ def process_match_tags(all_tags, filepath, logger):
         filepath = filepath[fmt_len:]
 
         # check that any extra text matches the filepath
-        filepath = check_pre_text(filepath, extra_text, logger)
+        filepath = _check_pre_text(filepath, extra_text)
         if filepath is None:
             return None, None
 
     return match_dict, valid_shift
 
-def check_pre_text(filepath, pre_text, logger=None):
+def _check_pre_text(filepath, pre_text):
     """! Check if there is an text before all tags and if they match the template.
          Strip off text from filepath.
          @param filepath path to check
@@ -573,7 +573,7 @@ def check_pre_text(filepath, pre_text, logger=None):
 
     return filepath
 
-def check_post_text(filepath, post_text, logger=None):
+def _check_post_text(filepath, post_text):
     """! Check if there is an text after all tags and if they match the template.
          Strip off text from filepath.
          @param filepath path to check
@@ -586,9 +586,6 @@ def check_post_text(filepath, post_text, logger=None):
     # do the same for text at the end of all tags
     if post_text:
         if post_text != filepath[-len(post_text):]:
-            # too much logging output comes from this - if verbose is added, this is a good candidate
-#            if logger:
-#                logger.debug("Text at end of filepath does not match template")
             return None
 
         # strip off post text from file path
diff --git a/metplus/util/system_util.py b/metplus/util/system_util.py
index f47d9a8936..8ac6f1e801 100644
--- a/metplus/util/system_util.py
+++ b/metplus/util/system_util.py
@@ -143,7 +143,7 @@ def prune_empty(output_dir, logger):
                 os.rmdir(full_dir)
 
 
-def get_files(filedir, filename_regex, logger=None):
+def get_files(filedir, filename_regex):
     """! Get all the files (with a particular naming format) by walking
         through the directories.
 
@@ -343,7 +343,7 @@ def is_met_netcdf(file_path):
     return True
 
 
-def get_filetype(filepath, logger=None):
+def get_filetype(filepath):
     """!This function determines if the filepath is a NETCDF or GRIB file
        based on the first eight bytes of the file.
        It returns the string GRIB, NETCDF, or a None object.
@@ -355,7 +355,6 @@ def get_filetype(filepath, logger=None):
        None is returned, without a system exit. (CURRENTLY NOT USED)
 
        @param filepath:  path/to/filename
-       @param logger the logger, optional
        @returns The string GRIB, NETCDF or a None object
     """
     # Developer Note
@@ -444,17 +443,3 @@ def get_filetype(filepath, logger=None):
         # ie. filepath references a file that does not exist
         # or filepath is a directory.
         return None
-
-    # Previous Logic
-    # ncdump_exe = config.getexe('NCDUMP')
-    #try:
-    #    result = subprocess.check_output([ncdump_exe, filepath])
-
-    #except subprocess.CalledProcessError:
-    #    return "GRIB"
-
-    #regex = re.search("netcdf", result)
-    #if regex is not None:
-    #    return "NETCDF"
-    #else:
-    #    return None
diff --git a/metplus/wrappers/command_builder.py b/metplus/wrappers/command_builder.py
index 9b32b40409..1adc35a01f 100755
--- a/metplus/wrappers/command_builder.py
+++ b/metplus/wrappers/command_builder.py
@@ -396,7 +396,7 @@ def get_env_copy(self, var_list=None):
         shell = self.c_dict.get('USER_SHELL', '').lower()
         for var in sorted(var_list):
             if shell == 'csh':
-                # TODO: Complex environment variables that have special characters
+                # NOTE: Complex environment variables that have special characters
                 # like { or } will not be copyable in csh until modifications are
                 # made to the formatting of the setenv calls
                 clean_env = self.env[var].replace('"', '"\\""')
@@ -519,8 +519,7 @@ def find_data(self, time_info, data_type='', mandatory=True,
         level = get_seconds_from_string(level, 'H')
 
         # arguments for find helper functions
-        arg_dict = {'level': level,
-                    'data_type': data_type_fmt,
+        arg_dict = {'data_type': data_type_fmt,
                     'mandatory': mandatory,
                     'time_info': time_info,
                     'return_list': return_list}
@@ -529,13 +528,14 @@ def find_data(self, time_info, data_type='', mandatory=True,
         if (self.c_dict.get(data_type_fmt + 'FILE_WINDOW_BEGIN', 0) == 0 and
                 self.c_dict.get(data_type_fmt + 'FILE_WINDOW_END', 0) == 0):
 
-            return self.find_exact_file(**arg_dict, allow_dir=allow_dir)
+            return self._find_exact_file(**arg_dict, allow_dir=allow_dir,
+                                         level=level)
 
         # if looking for a file within a time window:
-        return self.find_file_in_window(**arg_dict)
+        return self._find_file_in_window(**arg_dict)
 
-    def find_exact_file(self, level, data_type, time_info, mandatory=True,
-                        return_list=False, allow_dir=False):
+    def _find_exact_file(self, level, data_type, time_info, mandatory=True,
+                         return_list=False, allow_dir=False):
         input_template = self.c_dict.get(f'{data_type}INPUT_TEMPLATE', '')
         data_dir = self.c_dict.get(f'{data_type}INPUT_DIR', '')
 
@@ -544,9 +544,6 @@ def find_exact_file(self, level, data_type, time_info, mandatory=True,
                            "because no template was specified")
             return None
 
-        check_file_list = []
-        found_file_list = []
-
         # check if there is a list of files provided in the template
         # process each template in the list (or single template)
         template_list = getlist(input_template)
@@ -563,38 +560,11 @@ def find_exact_file(self, level, data_type, time_info, mandatory=True,
         # then add it back after the string sub call
         saved_level = time_info.pop('level', None)
 
-        input_must_exist = self.c_dict.get('INPUT_MUST_EXIST', True)
-
-        for template in template_list:
-            # perform string substitution on directory and template
-            full_template = os.path.join(data_dir, template)
-            full_path = do_string_sub(full_template,
-                                      level=level,
-                                      **time_info)
-
-            if os.path.sep not in full_path:
-                self.logger.debug(f"{full_path} is not a file path. "
-                                  "Returning that string.")
-                check_file_list.append(full_path)
-                input_must_exist = False
-                continue
-
-            self.logger.debug(f"Looking for {data_type}INPUT file {full_path}")
-
-            # if wildcard expression, get all files that match
-            if '?' in full_path or '*' in full_path:
-
-                wildcard_files = sorted(glob.glob(full_path))
-                self.logger.debug(f'Wildcard file pattern: {full_path}')
-                self.logger.debug(f'{str(len(wildcard_files))} files '
-                                  'match pattern')
+        input_must_exist = self._get_input_must_exist(template_list, data_dir)
 
-                # add files to list of files
-                for wildcard_file in wildcard_files:
-                    check_file_list.append(wildcard_file)
-            else:
-                # add single file to list
-                check_file_list.append(full_path)
+        check_file_list = self._get_files_to_check(template_list, level,
+                                                   time_info, data_dir,
+                                                   data_type)
 
         # if it was set, add level back to time_info
         if saved_level is not None:
@@ -614,6 +584,7 @@ def find_exact_file(self, level, data_type, time_info, mandatory=True,
         # return None if no files were found
         if not check_file_list:
             msg = f"Could not find any {data_type}INPUT files"
+            # warn instead of error if it is not mandatory to find files
             if not mandatory or not self.c_dict.get('MANDATORY', True):
                 self.logger.warning(msg)
             else:
@@ -621,14 +592,92 @@ def find_exact_file(self, level, data_type, time_info, mandatory=True,
 
             return None
 
-        for file_path in check_file_list:
-            # if file doesn't need to exist, skip check
-            if not input_must_exist:
-                found_file_list.append(file_path)
+        found_files = self._check_that_files_exist(check_file_list, data_type,
+                                                   allow_dir, mandatory,
+                                                   input_must_exist)
+        if found_files is None:
+            return None
+
+        # if only one item found and return_list is False, return single item
+        if len(found_files) == 1 and not return_list:
+            return found_files[0]
+
+        return found_files
+
+    def _get_input_must_exist(self, template_list, data_dir):
+        """!Check if input must exist. The config dict setting INPUT_MUST_EXIST
+        can force a False result to skip checks for files existing. Also, if
+        the "filename" in question is a keyword and not an actual path, then
+        the check for file existence will be skipped.
+
+        @param template_list list of filenames without substitution to check
+        @param data_dir string of the path to directory containing data
+        @returns True if input must exist or a failure will occur. False if
+        file existence checks can be skipped.
+        """
+        # if config variable explicitly overriding file existence check is set
+        if not self.c_dict.get('INPUT_MUST_EXIST', True):
+            return False
+
+        # if data directory is set to a path, then it is not a keyword
+        if os.path.sep in data_dir:
+            return True
+
+        # if the full path is set in the template (not in dir)
+        # but the template is not a path, then it is likely a keyword
+        # so skip file existence check
+        if any(os.path.sep not in template for template in template_list):
+            return False
+        return True
+
+    def _get_files_to_check(self, template_list, level, time_info, data_dir,
+                            data_type):
+        """!Get list of files to check if they exist.
+        @returns list of tuples containing file path and template used to build
+        that path -- template is used for error logging
+        """
+        check_file_list = []
+        for template in template_list:
+            # build full path with data directory and template
+            full_template = os.path.join(data_dir, template)
+
+            # perform string substitution on full path
+            full_path = do_string_sub(full_template, **time_info, level=level)
+
+            if os.path.sep not in full_path:
+                self.logger.debug(f"{full_path} is not a file path. "
+                                  "Returning that string.")
+                check_file_list.append((full_path, full_template))
                 continue
 
-            # check if file exists
-            input_data_type = self.c_dict.get(data_type + 'INPUT_DATATYPE', '')
+            self.logger.debug(f"Looking for {data_type}INPUT file {full_path}")
+
+            if '?' not in full_path and '*' not in full_path:
+                # add single file to list
+                check_file_list.append((full_path, full_template))
+                continue
+
+            # if wildcard expression, get all files that match
+            wildcard_files = sorted(glob.glob(full_path))
+            self.logger.debug(f'Wildcard file pattern: {full_path}')
+            self.logger.debug(f'{str(len(wildcard_files))} files '
+                              'match pattern')
+
+            # add files to list of files
+            for wildcard_file in wildcard_files:
+                check_file_list.append((wildcard_file, full_template))
+
+        return check_file_list
+
+    def _check_that_files_exist(self, check_file_list, data_type, allow_dir,
+                                mandatory, input_must_exist):
+        # if input doesn't need to exist, skip checks and return list of files
+        if not input_must_exist:
+            return [value for value, _ in check_file_list]
+
+        found_file_list = []
+        for file_path, template in check_file_list:
+            input_data_type = self.c_dict.get(f'{data_type}INPUT_DATATYPE', '')
             processed_path = preprocess_file(file_path,
                                              input_data_type,
                                              self.config,
@@ -654,31 +703,19 @@ def find_exact_file(self, level, data_type, time_info, mandatory=True,
                 self.logger.debug(f"Found file: {processed_path}")
             found_file_list.append(processed_path)
 
-        # if only one item found and return_list is False, return single item
-        if len(found_file_list) == 1 and not return_list:
-            return found_file_list[0]
-
         return found_file_list
 
-    def find_file_in_window(self, level, data_type, time_info, mandatory=True,
-                            return_list=False):
+    def _find_file_in_window(self, data_type, time_info, mandatory=True,
+                             return_list=False):
         template = self.c_dict[f'{data_type}INPUT_TEMPLATE']
         data_dir = self.c_dict[f'{data_type}INPUT_DIR']
 
         # convert valid_time to unix time
         valid_time = time_info['valid_fmt']
-        valid_seconds = int(datetime.strptime(valid_time, "%Y%m%d%H%M%S").strftime("%s"))
-        # get time of each file, compare to valid time, save best within range
-        closest_files = []
-        closest_time = 9999999
 
         # get range of times that will be considered
         valid_range_lower = self.c_dict.get(data_type + 'FILE_WINDOW_BEGIN', 0)
         valid_range_upper = self.c_dict.get(data_type + 'FILE_WINDOW_END', 0)
-        lower_limit = int(datetime.strptime(shift_time_seconds(valid_time, valid_range_lower),
-                                            "%Y%m%d%H%M%S").strftime("%s"))
-        upper_limit = int(datetime.strptime(shift_time_seconds(valid_time, valid_range_upper),
-                                            "%Y%m%d%H%M%S").strftime("%s"))
 
         msg = f"Looking for {data_type}INPUT files under {data_dir} within range " +\
               f"[{valid_range_lower},{valid_range_upper}] using template {template}"
@@ -688,44 +725,9 @@ def find_file_in_window(self, level, data_type, time_info, mandatory=True,
             self.log_error('Must set INPUT_DIR if looking for files within a time window')
             return None
 
-        # substitute any filename template tags that may be in _INPUT_DIR
-        data_dir = do_string_sub(data_dir, **time_info)
-
-        # step through all files under input directory in sorted order
-        for dirpath, _, all_files in os.walk(data_dir):
-            for filename in sorted(all_files):
-                fullpath = os.path.join(dirpath, filename)
-
-                # remove input data directory to get relative path
-                rel_path = fullpath.replace(f'{data_dir}/', "")
-                # extract time information from relative path using template
-                file_time_info = get_time_from_file(rel_path, template, self.logger)
-                if file_time_info is None:
-                    continue
-
-                # get valid time and check if it is within the time range
-                file_valid_time = file_time_info['valid'].strftime("%Y%m%d%H%M%S")
-                # skip if could not extract valid time
-                if not file_valid_time:
-                    continue
-                file_valid_dt = datetime.strptime(file_valid_time, "%Y%m%d%H%M%S")
-                file_valid_seconds = int(file_valid_dt.strftime("%s"))
-                # skip if outside time range
-                if file_valid_seconds < lower_limit or file_valid_seconds > upper_limit:
-                    continue
-
-                # if only 1 file is allowed, check if file is
-                # closer to desired valid time than previous match
-                if not self.c_dict.get('ALLOW_MULTIPLE_FILES', False):
-                    diff = abs(valid_seconds - file_valid_seconds)
-                    if diff < closest_time:
-                        closest_time = diff
-                        del closest_files[:]
-                        closest_files.append(fullpath)
-                # if multiple files are allowed, get all files within range
-                else:
-                    closest_files.append(fullpath)
-
+        closest_files = self._get_closest_files(data_dir, template, valid_time,
+                                                valid_range_lower,
+                                                valid_range_upper)
         if not closest_files:
             msg = (f"Could not find {data_type}INPUT files under {data_dir} within range "
                    f"[{valid_range_lower},{valid_range_upper}] using template {template}")
@@ -743,7 +745,7 @@ def find_file_in_window(self, level, data_type, time_info, mandatory=True,
             for ext in COMPRESSION_EXTENSIONS:
                 if filepath.endswith(ext) and filepath[0:-len(ext)] in closest_files:
                     duplicate_found = True
-                    continue
+                    break
 
             if not duplicate_found:
                 closest_files_fixed.append(filepath)
@@ -765,6 +767,60 @@ def find_file_in_window(self, level, data_type, time_info, mandatory=True,
 
         return out
 
+    def _get_closest_files(self, data_dir, template, valid_time,
+                           valid_range_lower, valid_range_upper):
+        closest_files = []
+
+        # get time of each file, compare to valid time, save best within range
+        closest_time = 9999999
+
+        valid_seconds = int(
+            datetime.strptime(valid_time, "%Y%m%d%H%M%S").strftime("%s")
+        )
+        lower_limit = int(datetime.strptime(shift_time_seconds(valid_time, valid_range_lower),
+                                            "%Y%m%d%H%M%S").strftime("%s"))
+        upper_limit = int(datetime.strptime(shift_time_seconds(valid_time, valid_range_upper),
+                                            "%Y%m%d%H%M%S").strftime("%s"))
+
+        # step through all files under input directory in sorted order
+        for dirpath, _, all_files in os.walk(data_dir):
+            for filename in sorted(all_files):
+                fullpath = os.path.join(dirpath, filename)
+
+                # remove input data directory to get relative path
+                rel_path = fullpath.replace(f'{data_dir}/', "")
+                # extract time information from relative path using template
+                file_time_info = get_time_from_file(rel_path, template,
+                                                    self.logger)
+                if file_time_info is None:
+                    continue
+
+                # get valid time and check if it is within the time range
+                file_valid_time = file_time_info['valid'].strftime("%Y%m%d%H%M%S")
+                # skip if could not extract valid time
+                if not file_valid_time:
+                    continue
+                file_valid_dt = datetime.strptime(file_valid_time, "%Y%m%d%H%M%S")
+                file_valid_seconds = int(file_valid_dt.strftime("%s"))
+                # skip if outside time range
+                if file_valid_seconds < lower_limit or file_valid_seconds > upper_limit:
+                    continue
+
+                # if multiple files are allowed, get all files within range
+                if self.c_dict.get('ALLOW_MULTIPLE_FILES', False):
+                    closest_files.append(fullpath)
+                    continue
+
+                # if only 1 file is allowed, check if file is
+                # closer to desired valid time than previous match
+                diff = abs(valid_seconds - file_valid_seconds)
+                if diff < closest_time:
+                    closest_time = diff
+                    del closest_files[:]
+                    closest_files.append(fullpath)
+
+        return closest_files
+
     def find_input_files_ensemble(self, time_info, fill_missing=True):
         """! Get a list of all input files and optional control file.
         Warn and remove control file if found in ensemble list. Ensure that
@@ -1009,12 +1065,12 @@ def check_for_externals(self):
 
     def check_for_gempak(self):
         # check if we are processing Gempak data
-        processingGempak = False
+        processing_gempak = False
 
         # if any *_DATATYPE keys in c_dict have a value of GEMPAK, we are using Gempak data
         data_types = [value for key,value in self.c_dict.items() if key.endswith('DATATYPE')]
         if 'GEMPAK' in data_types:
-            processingGempak = True
+            processing_gempak = True
 
         # if any filename templates end with .grd, we are using Gempak data
         template_list = [value for key,value in self.c_dict.items() if key.endswith('TEMPLATE')]
@@ -1029,10 +1085,10 @@ def check_for_gempak(self):
                 templates.append(value)
 
         if [value for value in templates if value and value.endswith('.grd')]:
-            processingGempak = True
+            processing_gempak = True
 
         # If processing Gempak, make sure GempakToCF is found
-        if processingGempak:
+        if processing_gempak:
             gempaktocf_jar = self.config.getstr('exe', 'GEMPAKTOCF_JAR', '')
             self.check_gempaktocf(gempaktocf_jar)
 
diff --git a/metplus/wrappers/command_runner.py b/metplus/wrappers/command_runner.py
index 1332e911a4..9c94738b5d 100755
--- a/metplus/wrappers/command_runner.py
+++ b/metplus/wrappers/command_runner.py
@@ -38,6 +38,7 @@
 import shlex
 from datetime import datetime, timezone
 
+
 class CommandRunner(object):
     """! Class for Creating and Running External Programs
     """
@@ -74,8 +75,7 @@ def run_cmd(self, cmd, env=None, log_name=None,
             return cmd
 
         # if env not set, use os.environ
-        if env is None:
-            env = os.environ
+        env = os.environ if env is None else env
 
         self.logger.info("COMMAND: %s" % cmd)
 
@@ -84,26 +84,13 @@ def run_cmd(self, cmd, env=None, log_name=None,
             self.logger.info("Not running command (DO_NOT_RUN_EXE = True)")
             return 0, cmd
 
-        # self.log_name MUST be defined in the subclass' constructor,
-        # this code block is a safety net in case that was not done.
-        # self.log_name is used to generate the MET log output name,
-        # if output is directed there, based on the conf settings.
-        #
-        # cmd.split()[0] 'should' be the /path/to/<some_met_binary>
-        if not log_name:
-            log_name = os.path.basename(cmd.split()[0])
-            self.logger.warning('MISSING self.log_name, '
-                                'setting name to: %s' % repr(log_name))
-            self.logger.warning('Fix the code and edit the following objects'
-                                ' contructor: %s, ' % repr(self))
+        log_name = log_name if log_name else os.path.basename(cmd.split()[0])
 
         # Determine where to send the output from the MET command.
         log_dest = self.get_log_path(log_filename=log_name+'.log')
 
         # determine if command must be run in a shell
-        run_inshell = False
-        if '*' in cmd or ';' in cmd or '<' in cmd or '>' in cmd:
-            run_inshell = True
+        run_inshell = '*' in cmd or ';' in cmd or '<' in cmd or '>' in cmd
 
         # KEEP This comment as a reference note.
         # Run the executable in a new process instead of through a shell.
@@ -138,7 +125,7 @@ def run_cmd(self, cmd, env=None, log_name=None,
         # run command
         try:
             ret = run(cmd_exe, **kwargs)
-        except:
+        except Exception:
             ret = -1
         else:
             # calculate time to run
diff --git a/metplus/wrappers/compare_gridded_wrapper.py b/metplus/wrappers/compare_gridded_wrapper.py
index 8cfa06821d..4d242d3ba9 100755
--- a/metplus/wrappers/compare_gridded_wrapper.py
+++ b/metplus/wrappers/compare_gridded_wrapper.py
@@ -320,7 +320,7 @@ def set_command_line_arguments(self, time_info):
 
         @param time_info dictionary with time information
         """
-        return
+        return None
 
     def get_command(self):
         """! Builds the command to run the MET application
diff --git a/metplus/wrappers/cyclone_plotter_wrapper.py b/metplus/wrappers/cyclone_plotter_wrapper.py
index e6ceda8be1..0e0de9009e 100644
--- a/metplus/wrappers/cyclone_plotter_wrapper.py
+++ b/metplus/wrappers/cyclone_plotter_wrapper.py
@@ -129,41 +129,42 @@ def __init__(self, config, instance=None):
         # User-defined map extent, lons and lats
         if self.is_global_extent:
             self.logger.debug("Global extent")
+            return
+
+        self.logger.debug("Getting lons and lats that define the plot's extent")
+        west_lon = (self.config.getstr('config',
+                                       'CYCLONE_PLOTTER_WEST_LON', '')
+        )
+        east_lon = (self.config.getstr('config',
+                                       'CYCLONE_PLOTTER_EAST_LON', '')
+        )
+        north_lat = (self.config.getstr('config',
+                                        'CYCLONE_PLOTTER_NORTH_LAT', '')
+        )
+        south_lat = (self.config.getstr('config',
+                                        'CYCLONE_PLOTTER_SOUTH_LAT', '')
+        )
+
+        # Check for unconfigured lons and lats needed for defining the extent
+        if not west_lon:
+            self.log_error("Missing CYCLONE_PLOTTER_WEST_LON in config file. ")
         else:
-            self.logger.debug("Getting lons and lats that define the plot's extent")
-            west_lon = (self.config.getstr('config',
-                                           'CYCLONE_PLOTTER_WEST_LON', '')
-            )
-            east_lon = (self.config.getstr('config',
-                                           'CYCLONE_PLOTTER_EAST_LON', '')
-            )
-            north_lat = (self.config.getstr('config',
-                                            'CYCLONE_PLOTTER_NORTH_LAT', '')
-            )
-            south_lat = (self.config.getstr('config',
-                                            'CYCLONE_PLOTTER_SOUTH_LAT', '')
-            )
-
-            # Check for unconfigured lons and lats needed for defining the extent
-            if not west_lon:
-                self.log_error("Missing CYCLONE_PLOTTER_WEST_LON in config file. ")
-            else:
-                self.west_lon = (float(west_lon))
-            if not east_lon:
-                self.log_error("Missing CYCLONE_PLOTTER_EAST_LON in config file. ")
-            else:
-                self.east_lon = (float(east_lon))
-            if not south_lat:
-                self.log_error("Missing CYCLONE_PLOTTER_SOUTH_LAT in config file. ")
-            else:
-                self.south_lat = float(south_lat)
-            if not north_lat:
-                self.log_error("Missing CYCLONE_PLOTTER_NORTH_LAT in config file. ")
-            else:
-                self.north_lat = float(north_lat)
+            self.west_lon = (float(west_lon))
+        if not east_lon:
+            self.log_error("Missing CYCLONE_PLOTTER_EAST_LON in config file. ")
+        else:
+            self.east_lon = (float(east_lon))
+        if not south_lat:
+            self.log_error("Missing CYCLONE_PLOTTER_SOUTH_LAT in config file. ")
+        else:
+            self.south_lat = float(south_lat)
+        if not north_lat:
+            self.log_error("Missing CYCLONE_PLOTTER_NORTH_LAT in config file. ")
+        else:
+            self.north_lat = float(north_lat)
 
-            self.extent_region = [self.west_lon, self.east_lon, self.south_lat, self.north_lat]
-            self.logger.debug(f"extent region: {self.extent_region}")
+        self.extent_region = [self.west_lon, self.east_lon, self.south_lat, self.north_lat]
+        self.logger.debug(f"extent region: {self.extent_region}")
 
 
     def run_all_times(self):
@@ -187,14 +188,13 @@ def retrieve_data(self):
 
         """
         self.logger.debug("Begin retrieving data...")
-        all_tracks_list = []
 
         # Store the data in the track list.
         if os.path.isdir(self.input_data):
             self.logger.debug("Get data from all files in the directory " +
                               self.input_data)
             # Get the list of all files (full file path) in this directory
-            all_input_files = get_files(self.input_data, ".*.tcst", self.logger)
+            all_input_files = get_files(self.input_data, ".*.tcst")
 
             # read each file into pandas then concatenate them together
             df_list = [pd.read_csv(file, delim_whitespace=True) for file in all_input_files]
@@ -208,7 +208,6 @@ def retrieve_data(self):
             # if there are any NaN values in the ALAT, ALON, STORM_ID, LEAD, INIT, AMODEL, or VALID column,
             # drop that row of data (axis=0).  We need all these columns to contain valid data in order
             # to create a meaningful plot.
-            combined_df = combined.copy(deep=True)
             combined_df = combined.dropna(axis=0, how='any',
                                           subset=self.columns_of_interest)
 
@@ -435,8 +434,6 @@ def create_plot(self):
 
         # to be consistent with the NOAA website, use red for annotations, markers, and lines.
         pt_color = 'red'
-        cross_marker_size = self.cross_marker_size
-        circle_marker_size = self.circle_marker_size
 
         # Get all the lat and lon (i.e. x and y) points for the '+' and 'o' marker types
         # to be used in generating the scatter plots (one for the 0/12 hr and one for the 6/18 hr lead
@@ -454,12 +451,10 @@ def create_plot(self):
                 cross_lons.append(pt.lon)
                 cross_lats.append(pt.lat)
                 cross_annotations.append(pt.annotation)
-                # cross_marker = pt.marker
             elif pt.marker == self.circle_marker:
                 circle_lons.append(pt.lon)
                 circle_lats.append(pt.lat)
                 circle_annotations.append(pt.annotation)
-                # circle_marker = pt.marker
 
         # Now generate the scatter plots for the lead group 0/12 hr ('+' marker) and the
         # lead group 6/18 hr ('.' marker).
@@ -644,9 +639,8 @@ def sanitize_lonlist(lon_list):
         treshold = 10
         for ix, ea in enumerate(lon_list):
             diff = oldval - ea
-            if (ix > 0):
-                if (diff > treshold):
-                    ea = ea + 360
+            if ix > 0 and diff > treshold:
+                ea = ea + 360
             oldval = ea
             new_list.append(ea)
 
diff --git a/metplus/wrappers/ensemble_stat_wrapper.py b/metplus/wrappers/ensemble_stat_wrapper.py
index adc764504a..5e621792a2 100755
--- a/metplus/wrappers/ensemble_stat_wrapper.py
+++ b/metplus/wrappers/ensemble_stat_wrapper.py
@@ -404,12 +404,37 @@ def run_at_time_all_fields(self, time_info):
                                               fill_missing=fill_missing):
             return
 
+        if not self.set_command_line_arguments(time_info):
+            return
+
+        # parse optional var list for FCST and/or OBS fields
+        var_list = sub_var_list(self.c_dict['VAR_LIST_TEMP'], time_info)
+
+        # set field info
+        fcst_field = self.get_all_field_info(var_list, 'FCST')
+        obs_field = self.get_all_field_info(var_list, 'OBS')
+
+        if not fcst_field and not obs_field:
+            self.log_error("Could not build field info for fcst or obs")
+            return
+
+        self.format_field('FCST', fcst_field)
+        self.format_field('OBS', obs_field)
+
+        self.process_fields(time_info)
+
+    def set_command_line_arguments(self, time_info):
+        """! Set all arguments for plot_point_obs command.
+
+        @param time_info dictionary containing timing information
+        @returns False if files could not be found, True on success
+        """
         # get point observation file if requested
         if self.c_dict['OBS_POINT_INPUT_TEMPLATE']:
             point_obs_files = self.find_data(time_info, data_type='OBS_POINT',
                                              return_list=True)
             if point_obs_files is None:
-                return
+                return False
 
             for point_obs_path in point_obs_files:
                 self.args.append(f'-point_obs "{point_obs_path}"')
@@ -419,7 +444,7 @@ def run_at_time_all_fields(self, time_info):
             grid_obs_files = self.find_data(time_info, data_type='OBS_GRID',
                                             return_list=True)
             if grid_obs_files is None:
-                return
+                return False
 
             for grid_obs_path in grid_obs_files:
                 self.args.append(f'-grid_obs "{grid_obs_path}"')
@@ -429,25 +454,11 @@ def run_at_time_all_fields(self, time_info):
             ens_mean_path = self.find_data(time_info, data_type='ENS_MEAN',
                                            return_list=True)
             if ens_mean_path is None:
-                return
+                return False
 
             self.args.append(f'-ens_mean {ens_mean_path[0]}')
 
-        # parse optional var list for FCST and/or OBS fields
-        var_list = sub_var_list(self.c_dict['VAR_LIST_TEMP'], time_info)
-
-        # set field info
-        fcst_field = self.get_all_field_info(var_list, 'FCST')
-        obs_field = self.get_all_field_info(var_list, 'OBS')
-
-        if not fcst_field and not obs_field:
-            self.log_error("Could not build field info for fcst or obs")
-            return
-
-        self.format_field('FCST', fcst_field)
-        self.format_field('OBS', obs_field)
-
-        self.process_fields(time_info)
+        return True
 
     def get_all_field_info(self, var_list, data_type):
         """!Get field info based on data type"""
diff --git a/metplus/wrappers/gfdl_tracker_wrapper.py b/metplus/wrappers/gfdl_tracker_wrapper.py
index bd492d04bc..770093f4fa 100755
--- a/metplus/wrappers/gfdl_tracker_wrapper.py
+++ b/metplus/wrappers/gfdl_tracker_wrapper.py
@@ -200,18 +200,7 @@ def create_c_dict(self):
         )
 
         # read config variables
-        for name, input_type in self.CONFIG_NAMES.items():
-            if input_type == 'int':
-                get_fct = self.config.getint
-            elif input_type == 'float':
-                get_fct = self.config.getfloat
-            elif input_type == 'bool':
-                get_fct = self.config.getbool
-            else:
-                get_fct = self.config.getraw
-
-            value = get_fct('config', f'GFDL_TRACKER_{name}', '')
-            c_dict[f'REPLACE_CONF_{name}'] = value
+        self._read_gfdl_config_variables(c_dict)
 
         c_dict['KEEP_INTERMEDIATE'] = (
             self.config.getbool('config',
@@ -238,6 +227,20 @@ def create_c_dict(self):
 
         return c_dict
 
+    def _read_gfdl_config_variables(self, c_dict):
+        for name, input_type in self.CONFIG_NAMES.items():
+            if input_type == 'int':
+                get_fct = self.config.getint
+            elif input_type == 'float':
+                get_fct = self.config.getfloat
+            elif input_type == 'bool':
+                get_fct = self.config.getbool
+            else:
+                get_fct = self.config.getraw
+
+            value = get_fct('config', f'GFDL_TRACKER_{name}', '')
+            c_dict[f'REPLACE_CONF_{name}'] = value
+
     def run_at_time(self, input_dict):
         """! Do some processing for the current run time (init or valid)
 
@@ -344,7 +347,7 @@ def handle_gen_vitals(self, input_dict):
                                  'tcvit_genesis_storms.txt')
         try:
             shutil.copyfile(src_path, dest_path)
-        except:
+        except (OSError, shutil.SameFileError):
             self.log_error(f"Copy failed: from {src_path} to {dest_path}")
             return False
 
@@ -361,7 +364,7 @@ def handle_gen_vitals(self, input_dict):
 
         try:
             shutil.copyfile(src_path, dest_path)
-        except:
+        except (OSError, shutil.SameFileError):
             self.log_error(f"Copy failed: from {src_path} to {dest_path}")
             return False
 
@@ -507,8 +510,8 @@ def create_fort_14_file(self, tc_vitals_out):
 
         # if not, create a blank file
         self.logger.debug(f"Writing blank fort.14 file: {fort_14_path}")
-        with open(fort_14_path, 'w'):
-            pass
+        file_handle = open(fort_14_path, 'w')
+        file_handle.close()
 
     def create_fort_15_file(self, all_lead_minutes):
         # format must match index (starting with 1) taking up 4 characters
diff --git a/metplus/wrappers/pcp_combine_wrapper.py b/metplus/wrappers/pcp_combine_wrapper.py
index 12992f7fa6..a02cacb7da 100755
--- a/metplus/wrappers/pcp_combine_wrapper.py
+++ b/metplus/wrappers/pcp_combine_wrapper.py
@@ -179,7 +179,7 @@ def set_fcst_or_obs_dict_items(self, d_type, c_dict):
         fill_num = (len(c_dict[f'{d_type}_EXTRA_NAMES']) -
                     len(c_dict[f'{d_type}_EXTRA_LEVELS']))
         if fill_num > 0:
-            for num in range(fill_num):
+            for _ in range(fill_num):
                 c_dict[f'{d_type}_EXTRA_LEVELS'].append(None)
 
         c_dict[f'{d_type}_EXTRA_OUTPUT_NAMES'] = getlist(
@@ -285,14 +285,13 @@ def run_at_time_one_field(self, time_info, var_info, data_src):
 
         # add -name argument
         output_name = self.c_dict.get(f'{data_src}_OUTPUT_NAME')
-        if not output_name:
-            if var_info:
-                output_name = var_info.get(f"{data_src.lower()}_name")
-                self.logger.warning(
-                    f'{data_src}_PCP_COMBINE_OUTPUT_NAME is '
-                    f'not set. Using {output_name} from '
-                    f'{data_src}_VAR{var_info.get("index")}_NAME.'
-                )
+        if not output_name and var_info:
+            output_name = var_info.get(f"{data_src.lower()}_name")
+            self.logger.warning(
+                f'{data_src}_PCP_COMBINE_OUTPUT_NAME is '
+                f'not set. Using {output_name} from '
+                f'{data_src}_VAR{var_info.get("index")}_NAME.'
+            )
 
         if output_name:
             self._handle_name_argument(output_name, data_src)
diff --git a/metplus/wrappers/py_embed_ingest_wrapper.py b/metplus/wrappers/py_embed_ingest_wrapper.py
index 9999fe0659..22732f4734 100755
--- a/metplus/wrappers/py_embed_ingest_wrapper.py
+++ b/metplus/wrappers/py_embed_ingest_wrapper.py
@@ -62,7 +62,6 @@ def create_c_dict(self):
                 self.log_error(f'Must set PY_EMBED_INGEST_{index}_OUTPUT_GRID')
 
 
-            # TODO: handle multiple scripts if they are defined
             ingest_script_search_text = f'PY_EMBED_INGEST_{index}_SCRIPT'
             regex = re.compile(ingest_script_search_text + r"(.*)")
             ingest_script_addons = []
@@ -171,8 +170,6 @@ def run_at_time_lead(self, time_info):
 
             rdp.infiles.append(f"PYTHON_{ingester['input_type']}")
 
-            # TODO: loop over scripts and output_field_names and add each
-            # get call to python script
             for script_raw in ingester['scripts']:
                 script = do_string_sub(script_raw,
                                        **time_info)
diff --git a/metplus/wrappers/reformat_gridded_wrapper.py b/metplus/wrappers/reformat_gridded_wrapper.py
index 9acb458595..fc0dd50789 100755
--- a/metplus/wrappers/reformat_gridded_wrapper.py
+++ b/metplus/wrappers/reformat_gridded_wrapper.py
@@ -40,7 +40,6 @@ def run_at_time_once(self, time_info, var_list, data_type):
         """!To be implemented by child class"""
         self.log_error('ReformatGridded wrapper cannot be called directly.'
                        ' Please use child wrapper')
-        return
 
     def run_at_time(self, input_dict):
         """! Runs the MET application for a given run time. Processing forecast
diff --git a/metplus/wrappers/series_analysis_wrapper.py b/metplus/wrappers/series_analysis_wrapper.py
index f592737c20..e1394f425a 100755
--- a/metplus/wrappers/series_analysis_wrapper.py
+++ b/metplus/wrappers/series_analysis_wrapper.py
@@ -668,12 +668,8 @@ def _get_fcst_and_obs_path(self, time_info, storm_id, lead_group):
         time_info['storm_id'] = storm_id
 
         # get label and lead list if grouping by forecast leads
-        if lead_group:
-            label = lead_group[0]
-            leads = lead_group[1]
-        else:
-            label = ''
-            leads = None
+        label = '' if not lead_group else lead_group[0]
+        leads = None if not lead_group else lead_group[1]
 
         # if file list are explicitly specified,
         # return the file list file paths
diff --git a/metplus/wrappers/stat_analysis_wrapper.py b/metplus/wrappers/stat_analysis_wrapper.py
index ea7f79a6d7..180908f542 100755
--- a/metplus/wrappers/stat_analysis_wrapper.py
+++ b/metplus/wrappers/stat_analysis_wrapper.py
@@ -248,7 +248,8 @@ def _run_stat_analysis(self, time_input):
             self.log_error('Could not get runtime settings dict list')
             return False
 
-        self._run_stat_analysis_job(runtime_settings_dict_list)
+        for runtime_settings in runtime_settings_dict_list:
+            self._run_stat_analysis_job(runtime_settings)
 
         return True
 
@@ -308,55 +309,52 @@ def _get_all_runtime_settings(self, time_input):
 
         return formatted_runtime_settings_dict_list
 
-    def _run_stat_analysis_job(self, runtime_settings_dict_list):
-        """! Sets environment variables need to run StatAnalysis jobs
-             and calls the tool for each job.
+    def _run_stat_analysis_job(self, runtime_settings):
+        """!Set environment variables to run StatAnalysis job and call it.
 
-             Args:
-                 @param runtime_settings_dict_list list of dictionaries
-                  containing information needed to run a StatAnalysis job
+        @param runtime_settings_dict_list list of dictionaries
+         containing information needed to run a StatAnalysis job
         """
-        for runtime_settings in runtime_settings_dict_list:
-            self.clear()
-            if not self._create_output_directories(runtime_settings):
-                continue
+        self.clear()
+        if not self._create_output_directories(runtime_settings):
+            return
 
-            # set METPLUS_ env vars for MET config file to be consistent
-            # with other wrappers
-            for key in self.WRAPPER_ENV_VAR_KEYS:
-                item = key.replace('METPLUS_', '')
-                if not runtime_settings.get(item, ''):
-                    continue
-                value = runtime_settings.get(item, '')
-                if key.endswith('_JOBS'):
-                    value = '["' + '","'.join(value) + '"]'
-                elif key.endswith('_BEG') or key.endswith('_END'):
-                    value = f'"{value}"'
-                else:
-                    value = f'[{value}]'
-                value = f'{item.lower()} = {value};'
-                self.env_var_dict[key] = value
-
-            # send environment variables to logger
-            self.set_environment_variables(runtime_settings['string_sub'])
-
-            # set lookin dir to add to command
-            self.logger.debug("Setting -lookin dir to "
-                              f"{runtime_settings['LOOKIN_DIR']}")
-            self.c_dict['LOOKIN_DIR'] = runtime_settings['LOOKIN_DIR']
-
-            # set any command line arguments
-            if self.c_dict.get('CONFIG_FILE'):
-                self.args.append(f"-config {self.c_dict['CONFIG_FILE']}")
+        # set METPLUS_ env vars for MET config file to be consistent
+        # with other wrappers
+        for key in self.WRAPPER_ENV_VAR_KEYS:
+            item = key.replace('METPLUS_', '')
+            if not runtime_settings.get(item, ''):
+                continue
+            value = runtime_settings.get(item, '')
+            if key.endswith('_JOBS'):
+                value = '["' + '","'.join(value) + '"]'
+            elif key.endswith('_BEG') or key.endswith('_END'):
+                value = f'"{value}"'
             else:
-                self.args.append(runtime_settings['JOBS'][0])
+                value = f'[{value}]'
+            value = f'{item.lower()} = {value};'
+            self.env_var_dict[key] = value
+
+        # send environment variables to logger
+        self.set_environment_variables(runtime_settings['string_sub'])
+
+        # set lookin dir to add to command
+        self.logger.debug("Setting -lookin dir to "
+                          f"{runtime_settings['LOOKIN_DIR']}")
+        self.c_dict['LOOKIN_DIR'] = runtime_settings['LOOKIN_DIR']
+
+        # set any command line arguments
+        if self.c_dict.get('CONFIG_FILE'):
+            self.args.append(f"-config {self.c_dict['CONFIG_FILE']}")
+        else:
+            self.args.append(runtime_settings['JOBS'][0])
 
-            # set -out file path if requested, value will be set to None if not
-            output_filename = runtime_settings.get('OUTPUT_FILENAME')
-            if output_filename:
-                self.args.append(f"-out {output_filename}")
+        # set -out file path if requested, value will be set to None if not
+        output_filename = runtime_settings.get('OUTPUT_FILENAME')
+        if output_filename:
+            self.args.append(f"-out {output_filename}")
 
-            self.build()
+        self.build()
 
     def _read_jobs_from_config(self):
         """! Parse the jobs from the METplusConfig object
diff --git a/metplus/wrappers/tc_gen_wrapper.py b/metplus/wrappers/tc_gen_wrapper.py
index bec1e1a567..db77f7cc5e 100755
--- a/metplus/wrappers/tc_gen_wrapper.py
+++ b/metplus/wrappers/tc_gen_wrapper.py
@@ -289,8 +289,6 @@ def create_c_dict(self):
     def handle_filter(self):
         """! find all TC_GEN_FILTER_<n> values in the config files
         """
-        filters = []
-
         all_config = self.config.keys('config')
         indices = []
         regex = re.compile(r"TC_GEN_FILTER_(\d+)")
@@ -299,10 +297,8 @@ def handle_filter(self):
             if result is not None:
                 indices.append(result.group(1))
 
-        for index in indices:
-            filter = self.config.getraw('config', f'TC_GEN_FILTER_{index}')
-            filters.append(filter)
-
+        filters = [self.config.getraw('config', f'TC_GEN_FILTER_{index}')
+                   for index in indices]
         if filters:
             filter_string = 'filter = [{'
             filter_string += '}, {'.join(filters)
diff --git a/metplus/wrappers/tc_pairs_wrapper.py b/metplus/wrappers/tc_pairs_wrapper.py
index aea5b9defa..13dafb1ed1 100755
--- a/metplus/wrappers/tc_pairs_wrapper.py
+++ b/metplus/wrappers/tc_pairs_wrapper.py
@@ -449,7 +449,6 @@ def _handle_diag_convert_map(self):
                                                dict_items=dict_items)
         if not return_code:
             self.isOK = False
-            return
 
     def _handle_diag(self, c_dict):
         diag_indices = list(
@@ -786,28 +785,30 @@ def _get_basin_cyclone_from_bdeck(self, bdeck_file, wildcard_used,
         bdeck_regex = bdeck_regex.replace('*', '(.*)').replace('?', '(.)')
         self.logger.debug(f'Regex to extract basin/cyclone: {bdeck_regex}')
 
+        match = re.match(bdeck_regex, bdeck_file)
+        if not match:
+            return basin, cyclone
+
         current_basin = basin
         current_cyclone = cyclone
 
-        match = re.match(bdeck_regex, bdeck_file)
-        if match:
-            matches = match.groups()
-            # get template tags and wildcards from template
-            tags = get_tags(bdeck_template)
-            if len(matches) != len(tags):
-                self.log_error("Number of regex match groups does not match "
-                               "number of tags found:\n"
-                               f"Regex pattern: {bdeck_template}\n"
-                               f"Matches: {matches}\nTags: {tags}")
-                return None, None
-
-            for match, tag in zip(matches, tags):
-                # if basin/cyclone if found, get value
-                if tag == 'basin' and basin == self.WILDCARDS['basin']:
-                    current_basin = match
-                elif (tag == 'cyclone' and
-                      cyclone == self.WILDCARDS['cyclone']):
-                    current_cyclone = match
+        matches = match.groups()
+        # get template tags and wildcards from template
+        tags = get_tags(bdeck_template)
+        if len(matches) != len(tags):
+            self.log_error("Number of regex match groups does not match "
+                           "number of tags found:\n"
+                           f"Regex pattern: {bdeck_template}\n"
+                           f"Matches: {matches}\nTags: {tags}")
+            return None, None
+
+        for match, tag in zip(matches, tags):
+            # if basin/cyclone if found, get value
+            if tag == 'basin' and basin == self.WILDCARDS['basin']:
+                current_basin = match
+            elif (tag == 'cyclone' and
+                  cyclone == self.WILDCARDS['cyclone']):
+                current_cyclone = match
 
         return current_basin, current_cyclone
 
diff --git a/produtil/cluster.py b/produtil/cluster.py
index 620e4ad603..c9fc600ba3 100644
--- a/produtil/cluster.py
+++ b/produtil/cluster.py
@@ -1,10 +1,12 @@
-"""!Provides information about the cluster on which this job is running"""
+"""!Provides information about the cluster on which this job is running.""" 
+"""Remove and clean WCOSS Cray and WCOSS Dell_p3 related logic and updating
+prodcution machine identifying logic for WCOSS2 (Biju Thomas 10/12/2022)"""
 
 ##@var __all__
 #List of symbols exported by "from produtil.cluster import *"
 __all__=['Cluster','where','longname','name','group_quotas','acl_support',
          'no_access_control','use_acl_for_rstdata','ncepprod',
-         'NOAAJet','NOAAGAEA','NOAAZeus','NOAAWCOSS']
+         'MSUOrion','NOAAJet','NOAAGAEA','NOAAHera','NOAAWCOSS']
 
 import time, socket, os, re
 
@@ -90,23 +92,12 @@ def where():
         elif os.path.exists('/data') and os.path.exists('/scratch') and \
                 os.path.exists('/home'):
             here=WisconsinS4()
-        elif os.path.exists('/scratch3'):
-            theia=False
-            with open('/proc/cpuinfo','rt') as f:
-                for line in f.readlines(1000):
-                    if line.find('E5-2690')>=0:
-                        theia=True
-                        break
-            if theia:
+        elif os.path.exists('/scratch1'):
+            here=NOAAHera()
+            if os.path.exists('/scratch'):
                 here=NOAATheia()
-            else:
-                here=NOAAZeus()
-        elif os.path.exists('/ptmpd2'):
-            here=NOAAWCOSS()
-        elif os.path.exists('/usrx') and 'dell' in os.readlink('/usrx'):
-            here=NOAAWCOSS(phase=3)
-        elif os.path.exists('/gpfs/hps/nco'):
-            here=WCOSSCray()
+        elif os.path.exists('/lfs/h2/emc'):
+            here=WCOSS2()
         elif os.path.exists('/lustre/f2'):
             here=NOAAGAEA()
         else:
@@ -187,13 +178,12 @@ def __init__(self):
         super(NOAAGAEA,self).__init__(False,True,False,'gaea',
                                       'gaea.rdhpcs.noaa.gov')
 
-class NOAAZeus(Cluster):
-    """!Represents the NOAA Zeus cluster.  Allows ACLs to be used for
-    restricted data, and specifies that group quotas are in use."""
+class NOAAHera(Cluster):
+    """!Represents the NOAA Hera cluster.  Does not allow ACLs,
+    assumes no group quotas (fileset quotas instead)."""
     def __init__(self):
-        """!Constructor for NOAAZeus"""
-        super(NOAAZeus,self).__init__(True,True,False,'zeus',
-                                      'zeus.rdhpcs.noaa.gov')
+        super(NOAAHera,self).__init__(False,False,False,'hera',
+                                      'hera.rdhpcs.noaa.gov')
 
 class UCARYellowstone(Cluster):
     """!Represents the Yellowstone cluster.  Does not allow ACLs,
@@ -211,12 +201,12 @@ def __init__(self):
         super(WisconsinS4,self).__init__(
             True,False,False,'s4','s4.ssec.wisc.edu')
 
-class NOAATheia(Cluster):
-    """Represents the NOAA Theia cluster.  Does not allow ACLs,
+class MSUOrion(Cluster):
+    """Represents the MSU Orion cluster.  Does not allow ACLs,
     assumes no group quotas (fileset quotas instead)."""
     def __init__(self):
-        super(NOAATheia,self).__init__(
-            False,False,False,'theia','theia.rdhpcs.noaa.gov')
+        super(MSUOrion,self).__init__(
+            False,False,False,'orion','orion.hpc.msstate.edu')
 
 class NOAAWCOSS(Cluster):
     """!Represents the NOAA WCOSS clusters, Tide, Gyre and the test
@@ -237,13 +227,6 @@ def __init__(self,prod_cache_time=30,name=None,phase=None):
         time for which the result of self.production should be cached.
         Default: 30 seconds.
         @param prod_cache_time how long to cache the prod vs. dev information, in seconds"""
-        if name is None:
-            host1=socket.gethostname()[0:1]
-            if host1=='t':          name='tide'
-            elif host1=='g':        name='gyre'
-            elif host1=='v':        name='venus'
-            elif host1=='m':        name='mars'
-            else:                   name='eddy'  # should update for Dell test machine
 
         super(NOAAWCOSS,self).__init__(False,False,DO_NOT_SET,name,
                                        name+'.ncep.noaa.gov')
@@ -258,50 +241,14 @@ def uncache(self):
         self._lastprod=0
         self._phase=0;
 
-    ##@var partition
-    # Returns "phase1" on phase 1, or "phase2" on phase 2.
-    # The WCOSSCray.partition overrides this on the Cray.
-
-    @property
-    def partition(self):
-        wp=self.wcoss_phase
-        if wp==1: return 'phase1'
-        if wp==2: return 'phase2'
-        return 'unknown' # should never reach this line
-
-    @property
-    def wcoss_phase(self):
-        """!Returns integer 1 or 2 for WCOSS Phase 1 or WCOSS Phase 2,
-        respectively.  Returns 0 if the request is invalid, such as on
-        WCOSS Cray.
-
-        Scans /proc/cpuinfo for processor 32.  If processor 32 is
-        found, you are on Phase 2, which has 48 virtual processors per
-        node.  Otherwise, you are on Phase 1.  
-
-        @note Cached results are returned if available.  Use uncache()
-        to force regeneration of the information.
-
-        @returns 1 for WCOSS Phase 1, 2 for WCOSS Phase 2, or 0 for
-        WCOSS Cray"""
-        if self._phase is None:
-            phase=1
-            with open('/proc/cpuinfo','rt') as cpuinfo:
-                for line in cpuinfo:
-                    if re.match(r'(?i)^processor\s*:\s*32',line):
-                        phase=2
-                        break
-            self._phase=phase
-        return self._phase
-
     @property
     def production(self):
-        """!Is this the WCOSS production machine?  
+        """!Is this the WCOSS2 production machine?  
 
-        The name of the WCOSS production machine: tide, gyre, surge or
-        luna as determined by the /etc/prod file.
+        The name of the WCOSS2 production machine: cactus or dogwood
+        luna as determined by the /lfs/h1/ops/prod/config/prodmachinefile file.
 
-        @returns True or False: is this the WCOSS production machine?
+        @returns True or False: is this the WCOSS2 production machine?
 
         @note The return value may change during the execution of this
         program if a production switch happened.  A cached value is
@@ -312,48 +259,35 @@ def production(self):
         file, so the runtime is likely several milliseconds when the
         cache times out."""
         now=int(time.time())
-        if self._production is None or \
-                now-self._lastprod>self._prod_cache_time:
-            prod=False
-            if os.path.exists('/etc/prod'):
-                with open('/etc/prod','rt') as f:
-                    for line in f:
-                        if re.match('[a-z]+',line):
-                            prod = line.strip()==self.name
-                            break
-            self._production=prod
-            self._lastprod=int(time.time())
-            return prod
-        else:
+        if (self._production is not None and
+                now-self._lastprod<=self._prod_cache_time):
             return self._production
 
+        prod=False
+        if os.path.exists('/etc/prod'):
+            with open('/etc/prod','rt') as f:
+                for line in f:
+                    if re.match('[a-z]+',line):
+                        prod = line.strip()==self.name
+                        break
+        self._production=prod
+        self._lastprod=int(time.time())
+        return prod
+
+
 class WCOSSCray(NOAAWCOSS):
     """!This subclass of NOAAWCOSS handles the new Cray portions of
     WCOSS: Luna and Surge."""
     def __init__(self,name=None):
-        """!Create a new WCOSSCray object describing this cluster as a
+        """!Create a new WCOSS2 object describing this cluster as a
         Cray machine.
 
         @property name The name of the cluster.  Default is to check
-        the hostname with socket.gethosname() and decide "luna"
-        vs. "surge" based on the first letter of the hostname. """
+        the hostname with socket.gethosname() and decide "dogwood"
+        vs. "cactus" based on the first letter of the hostname. """
         if name is None:
             host1=socket.gethostname()[0:1]
-            if host1=='l':          name='luna'
-            elif host1=='s':        name='surge'
-            else:                   name='luna'
-        super(WCOSSCray,self).__init__(name=name)
-
-    ##@var partition
-    # Returns "cray" to indicate the user is on the Cray side of WCOSS
-
-    @property
-    def partition(self):
-        return 'cray'
-
-    @property
-    def wcoss_phase(self):
-        """!Returns 0 to indicate that this is not the IBM part of WCOSS.
-
-        @returns 0"""
-        return 0
+            if host1=='c':          name='cactus'
+            elif host1=='s':        name='dogwood'
+            else:                   name='cactus'
+        super(WCOSS2,self).__init__(name=name)
diff --git a/produtil/config.py b/produtil/config.py
index d4a0a764b3..f020838a10 100644
--- a/produtil/config.py
+++ b/produtil/config.py
@@ -9,7 +9,7 @@
 
 ##@var __all__
 # decides what symbols are imported by "from produtil.config import *"
-__all__=['from_file','from-string','confwalker','ProdConfig','fordriver','ENVIRONMENT','ProdTask']
+__all__=['from_file','confwalker','ProdConfig','ENVIRONMENT','ProdTask']
 
 import collections,re,string,os,logging,threading
 import os.path,sys
@@ -22,7 +22,6 @@
 from io import StringIO
 
 from produtil.datastore import Datastore,Task
-from produtil.fileop import *
 
 from produtil.numerics import to_datetime
 from string import Formatter
@@ -97,20 +96,21 @@ def slow_vformat(self,format_string,args,kwargs):
                 self.parse(format_string):
             if literal_text:
                 out.write(literal_text)
-            if field_name:
-                (obj, used_key) = self.get_field(field_name,args,kwargs)
-                if obj is None and used_key:
-                    obj=self.get_value(used_key,args,kwargs)
-                value=obj
-                if conversion=='s':
-                    value=str(value)
-                elif conversion=='r':
-                    value=repr(value)
-                elif conversion:
-                    raise ValueError('Unknown conversion %s'%(repr(conversion),))
-                if format_spec:
-                    value=value.__format__(format_spec)
-                out.write(value)
+            if not field_name:
+                continue
+            (obj, used_key) = self.get_field(field_name,args,kwargs)
+            if obj is None and used_key:
+                obj=self.get_value(used_key,args,kwargs)
+            value=obj
+            if conversion=='s':
+                value=str(value)
+            elif conversion=='r':
+                value=repr(value)
+            elif conversion:
+                raise ValueError('Unknown conversion %s'%(repr(conversion),))
+            if format_spec:
+                value=value.__format__(format_spec)
+            out.write(value)
         ret=out.getvalue()
         out.close()
         assert(ret is not None)
@@ -133,50 +133,53 @@ def get_value(self,key,args,kwargs):
         try:
             if isinstance(key,int):
                 return args[key]
-            conf=kwargs.get('__conf',None)
-            if key in kwargs:
-                v=kwargs[key]
-            elif '__taskvars' in kwargs \
-                    and kwargs['__taskvars'] \
-                    and key in kwargs['__taskvars']:
-                v=kwargs['__taskvars'][key]
-            else:
-                isec=key.find('/')
-                if isec>=0:
-                    section=key[0:isec]
-                    nkey=key[(isec+1):]
-                    if not section:
-                        section=kwargs.get('__section',None)
-                    if nkey:
-                        key=nkey
-                else:
-                    section=kwargs.get('__section',None)
-                conf=kwargs.get('__conf',None)
-                v=NOTFOUND
-                if section is not None and conf is not None:
-                    if conf.has_option(section,key):
-                        v=conf.get(section,key,raw=True)
-                    elif conf.has_option(section,'@inc'):
-                        for osec in conf.get(section,'@inc').split(','):
-                            if conf.has_option(osec,key):
-                                v=conf.get(osec,key,raw=True)
-                    if v is NOTFOUND:
-                        if conf.has_option('config',key):
-                            v=conf.get('config',key,raw=True)
-                        elif conf.has_option('dir',key):
-                            v=conf.get('dir',key,raw=True)
-                    if v is NOTFOUND:
-                        raise KeyError(key)
-
-            if isinstance(v,str):
-                if v.find('{')>=0 or v.find('%')>=0:
-                    vnew=self.vformat(v,args,kwargs)
-                    assert(vnew is not None)
-                    return vnew
+            v = _get_v(key, kwargs)
+            if isinstance(v,str) and (v.find('{')>=0 or v.find('%')>=0):
+                vnew=self.vformat(v,args,kwargs)
+                assert(vnew is not None)
+                return vnew
             return v
         finally:
             kwargs['__depth']-=1
 
+
+def _get_v(key, kwargs):
+    if key in kwargs:
+        return kwargs[key]
+    if ('__taskvars' in kwargs and kwargs['__taskvars']
+            and key in kwargs['__taskvars']):
+        return kwargs['__taskvars'][key]
+
+    isec = key.find('/')
+    if isec >= 0:
+        section = key[0:isec]
+        nkey = key[(isec + 1):]
+        if not section:
+            section = kwargs.get('__section', None)
+        if nkey:
+            key = nkey
+    else:
+        section = kwargs.get('__section', None)
+    conf = kwargs.get('__conf', None)
+    v = NOTFOUND
+    if section is None or conf is None:
+        return v
+    if conf.has_option(section, key):
+        return conf.get(section, key, raw=True)
+    if conf.has_option(section, '@inc'):
+        for osec in conf.get(section, '@inc').split(','):
+            if conf.has_option(osec, key):
+                v = conf.get(osec, key, raw=True)
+    if v is not NOTFOUND:
+        return v
+
+    if conf.has_option('config', key):
+        return conf.get('config', key, raw=True)
+    if conf.has_option('dir', key):
+        return conf.get('dir', key, raw=True)
+    raise KeyError(key)
+
+
 def qparse(format_string):
     """!Replacement for Formatter.parse which can be added to Formatter objects
     to turn {'...'} and {"..."} blocks into literal strings (the ... part).
@@ -187,9 +190,6 @@ def qparse(format_string):
                 type(format_string).__name__,repr(format_string)))
     result=list()
     literal_text=''
-    field_name=None
-    format_spec=None
-    conversion=None
     for m in re.finditer(r'''(?xs) (
             \{ \' (?P<qescape>  (?: \' (?! \} ) | [^'] )* ) \' \}
           | \{ \" (?P<dqescape> (?: \" (?! \} ) | [^"] )* ) \" \}
@@ -197,7 +197,7 @@ def qparse(format_string):
                \{
                   (?P<field_name>
                      [^\}:!\['"\{] [^\}:!\[]*
-                     (?: \. [a-zA-Z_][a-zA-Z_0-9]+
+                     (?: \. [a-zA-Z_]\w+
                        | \[ [^\]]+ \] )*
                   )
                   (?: ! (?P<conversion>[rs]) )?
@@ -228,14 +228,15 @@ def qparse(format_string):
                     m.group('format_spec'),
                     m.group('conversion') ) )
             literal_text=''
-        elif m.group('error'):
-            if m.group('error')=='{':
-                raise ValueError("Single '{' encountered in format string")
-            elif m.group('error')=='}':
-                raise ValueError("Single '}' encountered in format string")
-            else:
-                raise ValueError("Unexpected %s in format string"%(
-                        repr(m.group('error')),))
+        elif not m.group('error'):
+            continue
+        if m.group('error')=='{':
+            raise ValueError("Single '{' encountered in format string")
+        elif m.group('error')=='}':
+            raise ValueError("Single '}' encountered in format string")
+        else:
+            raise ValueError("Unexpected %s in format string"%(
+                    repr(m.group('error')),))
     if literal_text: 
         result.append( ( literal_text, None, None, None ) )
     return result
@@ -470,7 +471,7 @@ def confwalker(conf,start,selector,acceptor,recursevar):
             if key==recursevar:
                 for sec2 in reversed(val.split(',')):
                     trim=sec2.strip()
-                    if len(trim)>0 and not trim in touched:
+                    if len(trim)>0 and trim not in touched:
                         requested.append(trim)
 
 ########################################################################
@@ -539,15 +540,14 @@ def __init__(self,conf=None,quoted_literals=False,strict=False, inline_comment_p
         section or option duplicates are not allowed in a single 
         configuration source."""
         self._logger=logging.getLogger('prodconfig')
-        logger=self._logger
         self._lock=threading.RLock()
         self._formatter=ConfFormatter(bool(quoted_literals))
         self._time_formatter=ConfTimeFormatter(bool(quoted_literals))
         self._datastore=None
         self._tasknames=set()
-        # Added strict=False and inline_comment_prefixes for Python 3,
+        # Added strict=False and inline_comment_prefixes for Python 3, 
         # so everything works as it did before in Python 2.
-        # self._conf=ConfigParser(strict=False, inline_comment_prefixes=(';',)) if (conf is None) else conf
+        #self._conf=ConfigParser(strict=False, inline_comment_prefixes=(';',)) if (conf is None) else conf
         self._conf=ConfigParser(strict=strict, inline_comment_prefixes=inline_comment_prefixes) if (conf is None) else conf
         self._conf.optionxform=str
 
@@ -672,7 +672,7 @@ def from_args(self,args=None,allow_files=True,allow_options=True,
                     'instead.'%(type(arg).__name__,repr(arg)))
             if verbose: logger.info(arg)
             m=re.match(r'''(?x)
-              (?P<section>[a-zA-Z][a-zA-Z0-9_]*)
+              (?P<section>[a-zA-Z]\w*)
                \.(?P<option>[^=]+)
                =(?P<value>.*)$''',arg)
             if m:
@@ -702,10 +702,9 @@ def from_args(self,args=None,allow_files=True,allow_options=True,
             elif not os.path.isfile(path):
                 logger.error(path+': conf file is not a regular file.')
                 sys.exit(2)
-            elif not produtil.fileop.isnonempty(path):
-                if verbose:
-                    logger.warning(
-                        path+': conf file is empty.  Will continue anyway.')
+            elif not produtil.fileop.isnonempty(path) and verbose:
+                logger.warning(
+                    path+': conf file is empty.  Will continue anyway.')
             if verbose: logger.info('Conf input: '+repr(path))
             self.read(path)
 
@@ -1160,7 +1159,7 @@ def _interp(self,sec,opt,morevars=None,taskvars=None):
                                 got=self._conf.get(trim,opt,raw=True)
                                 gotted=True
                                 break
-                            except (KeyError,NoSectionError,NoOptionError) as e:
+                            except (KeyError,NoSectionError,NoOptionError):
                                 pass # var not in section; search elsewhere
                 if gotted: break
             else:
@@ -1168,7 +1167,7 @@ def _interp(self,sec,opt,morevars=None,taskvars=None):
                     got=self._conf.get(section,opt,raw=True)
                     gotted=True
                     break
-                except (KeyError,NoSectionError,NoOptionError) as e:
+                except (KeyError,NoSectionError,NoOptionError):
                     pass # var not in section; search elsewhere
 
         if not gotted:
@@ -1265,7 +1264,7 @@ def getstr(self,sec,opt,default=None,badtypeok=False,morevars=None,taskvars=None
         with self:
             return self._get(sec,opt,str,default,badtypeok,morevars,taskvars=taskvars)
 
-    def get(self,sec,opt,default=None,badtypeok=False,morevars=None,taskvars=None):
+    def get(self,sec,opt,default=None,morevars=None,taskvars=None):
         """!get the value of an option from a section
 
         Gets option opt from section sec, expands it and converts
@@ -1280,8 +1279,6 @@ def get(self,sec,opt,default=None,badtypeok=False,morevars=None,taskvars=None):
         @param sec,opt the section and option
         @param default if specified and not None, then the default is
           returned if an option has no value or the section does not exist
-        @param badtypeok is True, and the conversion fails, and a
-          default is specified, the default will be returned.
         @param morevars,taskvars dicts of more variables for string expansion"""
         with self:
             try:
@@ -1338,7 +1335,7 @@ def getbool(self,sec,opt,default=None,badtypeok=False,morevars=None,taskvars=Non
         if re.match(r'(?i)\A(?:F|\.false\.|false|no|off|0)\Z',s): return False
         try:
             return int(s)==0
-        except ValueError as e: pass
+        except ValueError: pass
         if badtypeok and default is not None:
             return bool(default)
         raise ValueError('%s.%s: invalid value for conf file boolean: %s'
@@ -1396,13 +1393,9 @@ def __init__(self,dstore,conf,section,taskname=None,workdir=None,
                                           logger=conf.log(taskname),**kwargs)
             mworkdir=self.meta('workdir','')
             moutdir=self.meta('outdir','')
-            if mworkdir: 
-                workdir=mworkdir
-            else:
+            if not mworkdir:
                 self['workdir']=workdir
-            if moutdir: 
-                outdir=moutdir
-            else:
+            if not moutdir:
                 self['outdir']=outdir
 
     def get_workdir(self):
diff --git a/produtil/datastore.py b/produtil/datastore.py
index da34117ccf..cb2a665956 100644
--- a/produtil/datastore.py
+++ b/produtil/datastore.py
@@ -178,7 +178,7 @@ def __init__(self,filename,logger=None,locking=True):
         self._file_lock=produtil.locking.LockFile(
             lockfile,logger=logger,max_tries=300,sleep_time=0.1,first_warn=50)
         self._transtack=collections.defaultdict(list)
-        with self.transaction() as tx:
+        with self.transaction():
             self._createdb(self._connection())
     ##@var db 
     # The underlying sqlite3 database object
@@ -219,9 +219,6 @@ def _unlock(self):
         if not self._locking: return
         self._file_lock.release()
         self._db_lock.release()
-        #if self._logger is not None:
-        #        self._logger.info('db lock release: '+\
-        #          (''.join(traceback.format_list(traceback.extract_stack(limit=10)))))
     def transaction(self):
         """!Starts a transaction on the database in the current thread."""
         return Transaction(self)
@@ -334,15 +331,12 @@ def init_datum(self,d,meta=True):
         prodtype=type(d).__name__
         av = d._meta['available'] if ('available' in d._meta) else 0
         loc = d._meta['location'] if ('location' in d._meta) else ''
-        #print 'INIT_DATUM with location=%s'%(repr(loc),)
         self.mutate('INSERT OR IGNORE INTO products VALUES (?,?,?,?)',(d.did,av,loc,prodtype))
         if loc is not None and loc!='':
             # Update the location if it is not set in the product
             # table, but is set in the initial values.
-            #print 'UPDATE LOCATION...'
             for (did,oloc) in \
                     self.query('SELECT id,location FROM products WHERE id = ?',(d.did,)):
-                #print 'LOCATION currently %s'%(oloc,)
                 if did==d.did and (oloc is None or oloc==''):
                     self.mutate('UPDATE products SET location=? WHERE id=?',
                                 (loc,d.did))
@@ -381,14 +375,12 @@ def refresh_meta(self,d,or_add=True):
             found=True
             meta['available']=av
             meta['location']=loc
-            #print 'refresh_meta update location=%s'%(repr(loc),)
             break
         if not found:
             if or_add:
                 self.init_datum(d,meta=False)
             meta['available']=0
             meta['location']=''
-            #print 'refresh_meta not found so location=""'
         for (did,k,v) in self.query('SELECT id, key, value FROM metadata WHERE id = ?',(d.did,)):
             meta[k]=v
         d._meta=meta
@@ -458,8 +450,6 @@ def __init__(self,dstore,prodname,category,meta=None,cache=30,location=None,**kw
         @param cache Metadata cache lifetime in seconds.
         @param location The initial value for location, if it is not set already in the database.
         @param kwargs Ignored."""
-        #print 'INIT WITH location=%s prodname=%s category=%s'% \
-        #    (repr(location),repr(prodname),repr(category))
         (self._dstore,self._prodname,self._category) = (dstore,str(prodname),str(category))
         self._id=self._category+'::'+self._prodname
         self._cachetime=time.time()
@@ -599,11 +589,11 @@ def __ne__(self,other):
     def __ge__(self,other):
         """!Compares two Datums' prodnames and categories.
         @param other the other datum to compare against"""
-        return not (self<other)
+        return self>=other
     def __le__(self,other):
         """!Compares two Datums' prodnames and categories.
         @param other the other datum to compare against"""
-        return not (self>other)
+        return self<=other
     def set_loc_avail(self,loc,avail):
         """!Sets the location and availability of this Datum in a
         single transaction.
@@ -624,13 +614,10 @@ def _getcache(self,k=None,force=False):
         @param k The key of interest.
         @param force If True, forces a cache update even if the
           cache is not expired."""
-        logger=self.dstore._logger
-        did=self.did
         if not force:
             age=time.time()-self._cachetime
-            if age<self._cacheage:
-                if k is None or k in self._meta:
-                    return self._meta
+            if age<self._cacheage and (k is None or k in self._meta):
+                return self._meta
         with self.transaction() as t:
             t.refresh_meta(self)
             self._cachetime=time.time()
@@ -1049,7 +1036,6 @@ def wait_for_products(plist,logger,renamer=None,action=None,
     if action_args is None: action_args=list()
     logger.info('Waiting for %d products.'%(int(len(plist)),))
     while len(seen)<len(plist) and now<start+maxtime:
-        now=int(time.time())
         for p in plist:
             if p in seen: continue
             if not p.available: p.check()
@@ -1172,7 +1158,6 @@ def products(self,*args,**kwargs):
         class.  The default implementation returns immediately without
         doing anything.
         @param args,kwargs Implementation-defined, used by subclasses."""
-        return
         for x in []: yield x  # ensures this is an iterator
     def log(self):
         """!Returns the logger object for this task."""
diff --git a/produtil/fileop.py b/produtil/fileop.py
index 687bec88e4..348daa6006 100644
--- a/produtil/fileop.py
+++ b/produtil/fileop.py
@@ -26,7 +26,7 @@
 class FileOpError(Exception):
     """!This is the superclass of several exceptions relating to
     multi-file operations in produtil.fileop."""
-    def __init__(self,message,filename,more=[]):
+    def __init__(self,message,filename,more=None):
         """!FileOpError constructor
         @param message the error message
         @param filename the name of the problematic file
@@ -35,7 +35,7 @@ def __init__(self,message,filename,more=[]):
           description of the problem with that pair."""
         self.message=message
         self.filename=filename
-        self.more=more
+        self.more=more if more else []
     ##@var message
     # The error message
 
@@ -237,7 +237,7 @@ def makedirs(filename,numtries=10,logger=None):
                 if logger is not None:
                     logger.info(filename+': make directory and parents')
                 os.makedirs(filename)
-        except EnvironmentError as e:
+        except EnvironmentError:
             if os.path.isdir(filename):
                 return True
             elif os.path.exists(filename):
@@ -335,7 +335,7 @@ def isnonempty(filename):
     @param filename The file to test."""
     if filename is None:           return None
     sfile=str(filename)
-    if sfile is None or sfile=='': return None
+    if not sfile: return None
     (l,s) = lstat_stat(filename)
     ret=s is not None and s.st_size>0
     return ret
@@ -426,15 +426,14 @@ def deliver_file(infile,outfile,keep=True,verify=False,blocksize=1048576,
     outdir=None # parent directory of target file
     (oflstat,ofstat)=lstat_stat(actual_outfile) # stat on target file
     (odlstat,odstat)=(None,None) # stat on target file's parent directory
-    if ofstat is not None:
-        if stat.S_ISDIR(ofstat.st_mode):
-            outdir=actual_outfile
-            actual_outfile=os.path.join(outfile,inbase)
-            (odlstat,odstat)=(oflstat,ofstat)
-            if logger is not None:
-                logger.debug('%s: is a directory; file is %s'
-                             %(outfile,inbase))
-            (oflstat,ofstat)=lstat_stat(actual_outfile)
+    if ofstat is not None and stat.S_ISDIR(ofstat.st_mode):
+        outdir=actual_outfile
+        actual_outfile=os.path.join(outfile,inbase)
+        (odlstat,odstat)=(oflstat,ofstat)
+        if logger is not None:
+            logger.debug('%s: is a directory; file is %s'
+                         %(outfile,inbase))
+        (oflstat,ofstat)=lstat_stat(actual_outfile)
     if odlstat is None:
         outdir=os.path.dirname(outfile)
         if len(outdir)<1: outdir='.'
@@ -449,10 +448,9 @@ def deliver_file(infile,outfile,keep=True,verify=False,blocksize=1048576,
             raise DeliveryFailed('Target does not exist, and parent of '
                                  'target is not a directory.',infile,outfile)
 
-    if odstat is not None and not force:
-        if logger is  not None:
-            logger.debug('%s: exists and overwrite (force) is disabled.  '
-                         'Aborting delivery.'%(actual_outfile,))
+    if odstat is not None and not force and logger is not None:
+        logger.debug('%s: exists and overwrite (force) is disabled.  '
+                     'Aborting delivery.'%(actual_outfile,))
 
     # Handle a special case: the source and destination are the same
     # and the destination is not a symlink.  In that case, we have
@@ -555,7 +553,7 @@ def deliver_file(infile,outfile,keep=True,verify=False,blocksize=1048576,
                 temp.close()
             if removefailed and tempname is not None:
                 os.unlink(tempname)
-        except EnvironmentError as e:
+        except EnvironmentError:
             pass
 
 ########################################################################
@@ -602,7 +600,7 @@ def symlink_read_test(filename,readsize=40,logger=None):
             buf=f.read(readsize)
             if logger is not None:
                 logger.info('%s: read %s'%(filename,repr(buf)))
-    except EnvironmentError as e:
+    except EnvironmentError:
         pass # ignore I/O and OS errors
 
 def make_symlinks_in(sources,targetdir,force=False,renamer=None,logger=None,
@@ -690,7 +688,7 @@ def make_symlink(source,target,force=False,logger=None,max_tries=20):
         else:
             pass # symlink_read_test(target,logger=logger)
     except EnvironmentError as e:
-        if not e.errno==errno.EEXIST or not force:
+        if e.errno!=errno.EEXIST or not force:
             raise
         # The file already exists
         if logger is not None:
@@ -915,8 +913,6 @@ def check_last_lines(filename,searchstr,lastbytes=10000,logger=None):
         i=0
         for line in f:
             i+=1
-            #print '%s: search line "%s" for "%s"'%(
-            #               filename,line,searchstr)
             if line.find(searchstr)>=0:
                 return True
         if logger is not None:
@@ -953,24 +949,21 @@ def check_file(filename,min_size=None,min_mtime_age=None,
         if min_mtime_age is not None or min_atime_age is not None \
                 or min_ctime_age is not None:
             now=int(time.time())
-            if min_mtime_age is not None:
-                if not now-s.st_mtime>min_mtime_age: 
-                    if logger is not None:
-                        logger.info('%s: not old enough (modification time)'
-                                    %(filename,))
-                    return False
-            if min_atime_age is not None:
-                if not now-s.st_atime>min_atime_age: 
-                    if logger is not None:
-                        logger.info('%s: not old enough (access time)'
-                                    %(filename,))
-                    return False
-            if min_ctime_age is not None:
-                if not now-s.st_ctime>min_ctime_age: 
-                    if logger is not None:
-                        logger.info('%s: not old enough (inode change time)'
-                                    %(filename,))
-                    return False
+            if min_mtime_age is not None and now-s.st_mtime<=min_mtime_age:
+                if logger is not None:
+                    logger.info('%s: not old enough (modification time)'
+                                %(filename,))
+                return False
+            if min_atime_age is not None and now-s.st_atime<=min_atime_age:
+                if logger is not None:
+                    logger.info('%s: not old enough (access time)'
+                                %(filename,))
+                return False
+            if min_ctime_age is not None and now-s.st_ctime<=min_ctime_age:
+                if logger is not None:
+                    logger.info('%s: not old enough (inode change time)'
+                                %(filename,))
+                return False
         if logger is not None:
             logger.info('%s: file meets requirements'%(filename,))
         return True
@@ -1074,19 +1067,17 @@ def checkfiles(self,maxwait=1800,sleeptime=20,logger=None,
         @param log_each_file log messages about each file checked"""
         maxwait=int(maxwait)
         start=int(time.time())
-        now=start
         first=True
         if log_each_file:
             flogger=logger
         else:
             flogger=None
-        while None is None:
+        while True:
             if len(self._fset)<=0: 
                 if logger is not None:
                     logger.info('No files to check.')
                 return True
 
-            left=len(self._fset)-len(self._found)
             now=int(time.time())
             nfiles=len(self._fset)
             nfound=len(self._found)
diff --git a/produtil/locking.py b/produtil/locking.py
index 745fd77965..1cf90fd277 100644
--- a/produtil/locking.py
+++ b/produtil/locking.py
@@ -50,7 +50,7 @@ def disable_locking():
     for lock in locks:
         try:
             lock.release_impl()
-        except (Exception,LockingDisabled) as l: pass
+        except (Exception,LockingDisabled): pass
 
 class LockHeld(Exception):
     """!This exception is raised when a LockFile cannot lock a file
diff --git a/produtil/log.py b/produtil/log.py
index 337aaec38b..329cab79f2 100644
--- a/produtil/log.py
+++ b/produtil/log.py
@@ -141,7 +141,7 @@ def stdout_is_stderr():
             return True
         if sys.stdout.isatty() and sys.stderr.isatty():
             return True
-    except Exception as e:
+    except Exception:
         pass
     return False
 
@@ -216,7 +216,7 @@ def emit(self,record):
                 for x in range(10):
                     try:
                         os.makedirs(dirn)
-                    except EnvironmentError as e:
+                    except EnvironmentError:
                         if os.path.isdir(dirn): 
                             break
                         elif os.path.exists(dirn):
@@ -280,7 +280,7 @@ def mpi_redirect(threadname,stderrfile,stdoutfile,
     if not isinstance(threadname,str):
         raise TypeError(
             "In mpiRedirect, the threadname must be a string, not a "
-            +type(threadname))
+            +type(threadname).__name__)
 
     global logthread
     logthread='['+str(threadname)+']'
@@ -319,7 +319,7 @@ def mpi_redirect(threadname,stderrfile,stdoutfile,
         if masterlevel!=logging.NOTSET:
             mloghandler.setLevel(masterlevel)
         else:
-            raise BaseException('no master level')
+            raise Exception('no master level')
         logging.getLogger().addHandler(mloghandler)
     global masterlogger
     masterlogger=logging.getLogger(masterdomain)
@@ -377,7 +377,6 @@ def configureLogging(jlogfile=None,
         root.setLevel(level) # set global minimum logging level
 
     # Configure log formatting:
-    jlog=logging.getLogger('jlogfile')
     jobstr=os.environ.get('job',None)
     if jobstr is None:
         jobstr=produtil.batchsystem.jobname()
diff --git a/produtil/mpi_impl/__init__.py b/produtil/mpi_impl/__init__.py
index 7e57ff4653..b986e7d76c 100644
--- a/produtil/mpi_impl/__init__.py
+++ b/produtil/mpi_impl/__init__.py
@@ -232,10 +232,7 @@ def register_implementations(logger=None):
         # If we have srun, and we're in a pack group...
         import produtil.mpi_impl.srun_pack_groups
         add_implementation(produtil.mpi_impl.srun_pack_groups.Implementation)
-    except ImportError as e: 
-        # Some projects prefer to suppress this log message.
-        # Temp comment out until this can be addressed properly.
-        #logger.info('srun: cannot import: %s'%(str(e),))
+    except ImportError:
         pass
 
     try:
@@ -243,62 +240,55 @@ def register_implementations(logger=None):
         # If we have srun and SLURM resources...
         import produtil.mpi_impl.srun
         add_implementation(produtil.mpi_impl.srun.Implementation)
-    except ImportError as e: 
-        # Some projects prefer to suppress this log message.
-        # Temp comment out until this can be addressed properly.
-        #logger.info('srun: cannot import: %s'%(str(e),))
+    except ImportError:
         pass
 
     try:
         import produtil.mpi_impl.inside_aprun
         add_implementation(produtil.mpi_impl.inside_aprun.Implementation)
-    except ImportError as e: 
-        # Some projects prefer to suppress this log message.
-        # Temp comment out until this can be addressed properly.
-        #logger.info('inside_aprun: cannot import: %s'%(str(e),))
+    except ImportError:
+        pass
+
+    try:
+        import produtil.mpi_impl.pbs_cray_intel
+        add_implementation(produtil.mpi_impl.pbs_cray_intel.Implementation)
+    except ImportError:
         pass
 
     try:
         import produtil.mpi_impl.lsf_cray_intel
         add_implementation(produtil.mpi_impl.lsf_cray_intel.Implementation)
-    except ImportError as e: 
-        # Some projects prefer to suppress this log message.
-        # Temp comment out until this can be addressed properly.
-        #logger.info('lsf_cray_intel: cannot import: %s'%(str(e),))
+    except ImportError:
         pass
 
     try:
         import produtil.mpi_impl.impi
         add_implementation(produtil.mpi_impl.impi.Implementation)
-    except ImportError as e: 
-        # Some projects prefer to suppress this log message.
-        # Temp comment out until this can be addressed properly.
-        #logger.info('impi: cannot import: %s'%(str(e),))
+    except ImportError:
         pass
 
     try:
         import produtil.mpi_impl.mpirun_lsf
         add_implementation(produtil.mpi_impl.mpirun_lsf.Implementation)
-    except ImportError as e: 
-        #logger.info('mpirun_lsf: cannot import: %s'%(str(e),))
+    except ImportError:
         pass
 
     try:
         import produtil.mpi_impl.mpiexec_mpt
         add_implementation(produtil.mpi_impl.mpiexec_mpt.Implementation)
-    except ImportError as e: 
-        # Some projects prefer to suppress this log message.
-        # Temp comment out until this can be addressed properly.
-        #logger.info('mpiexec_mpt: cannot import: %s'%(str(e),))
+    except ImportError:
         pass
 
     try:
         import produtil.mpi_impl.mpiexec
         add_implementation(produtil.mpi_impl.mpiexec.Implementation)
-    except ImportError as e: 
-        # Some projects prefer to suppress this log message.
-        # Temp comment out until this can be addressed properly.
-        #logger.info('mpiexec: cannot import: %s'%(str(e),))
+    except ImportError:
+        pass
+
+    try:
+        import produtil.mpi_impl.srun_shell
+        add_implementation(produtil.mpi_impl.srun_shell.Implementation)
+    except ImportError:
         pass
 
 def get_mpi(mpi_name=NO_NAME,force=False,logger=None,**kwargs):
@@ -362,16 +352,11 @@ def get_mpi(mpi_name=NO_NAME,force=False,logger=None,**kwargs):
                 force=force,logger=logger,**kwargs)
         except (Exception,
                 produtil.fileop.FileOpError,
-                produtil.prog.ExitStatusException) as ee:
+                produtil.prog.ExitStatusException):
             # Ignore exceptions related to an inability to detect the
             # MPI implementation.  We assume the issue has already
             # been logged, and we move on to the next implementation's
             # detection function.
-
-            # Some projects prefer to suppress this log message.
-            # Temp comment out until this can be addressed properly.
-            #logger.info('%s: not detected: %s'%(
-            #        name,str(ee)))
             pass
         if result:
             # Detection succeeded.
diff --git a/produtil/mpi_impl/mpi_impl_base.py b/produtil/mpi_impl/mpi_impl_base.py
index 701928ec51..572bfc63db 100644
--- a/produtil/mpi_impl/mpi_impl_base.py
+++ b/produtil/mpi_impl/mpi_impl_base.py
@@ -96,7 +96,6 @@ def __init__(self,logger=None):
     def synonyms():
         """!Iterates over alternative names for this MPI implementation, such
         as the names of other MPI implementations this class can handle."""
-        return
         yield 'xyz' # trick to ensure this is an iterator
 
     def getmpiserial_path(self):
@@ -141,9 +140,7 @@ def runsync(self,logger=None):
         """!Runs the "sync" command as an exe()."""
         if logger is None: logger=self.logger
         sync=produtil.prog.Runner(['/bin/sync'])
-        p=produtil.pipeline.Pipeline(sync,capture=True,logger=logger)
-        version=p.to_string()
-        status=p.poll()
+        produtil.pipeline.Pipeline(sync,capture=True,logger=logger)
     def openmp(self,arg,threads):
         """!Does nothing.  This implementation does not support OpenMP.
     
@@ -228,7 +225,7 @@ def __init__(self,base,lines,cmd_envar='SCR_CMDFILE',
         if len(out)>0:
             out+='\n'
         self.cmdf_contents=out
-        return
+
     ##@var filename
     # command file's filename
 
@@ -281,9 +278,7 @@ def __call__(self,runner,logger=None):
                 self.info('Write command file to %s'%(repr(filename),),logger)
             kw={self.cmd_envar: self.filename}
             self._add_more_vars(kw,logger)
-            if logger is not None:
-                for k,v in kw.items():
-                    self.info('Set %s=%s'%(k,repr(v)),logger)
+            self._log_kw(kw, logger)
             if self.filename_arg:
                 if filename_option:
                     runner=runner[self.filename_option]
@@ -299,9 +294,7 @@ def __call__(self,runner,logger=None):
                 os.fchmod(t.fileno(),stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH)
                 kw={self.cmd_envar: t.name}
                 self._add_more_vars(kw,logger)
-                if logger is not None:
-                    for k,v in kw.items():
-                        self.info('Set %s=%s'%(k,repr(v)),logger)
+                self._log_kw(kw, logger)
                 runner.env(**kw)
                 if self.filename_arg:
                     if isinstance(self.filename_option,str):
@@ -311,6 +304,17 @@ def __call__(self,runner,logger=None):
         if self.next_prerun is not None:
             return self.next_prerun(result)
 
+    def _log_kw(self, kw, logger):
+        """!Log key values of kw if logger is set.
+
+        @param kw dictionary to log
+        @param logger a logging.Logger for log messages or None if not set
+        """
+        if logger is None:
+            return
+        for k, v in kw.items():
+            self.info('Set %s=%s' % (k, repr(v)), logger)
+
     def to_shell(self,runner,logger=None):
         """!Adds the environment variables to @c runner and generates
         shell code that would create the command file.
@@ -351,9 +355,7 @@ def to_shell(self,runner,logger=None):
 
         kw={self.cmd_envar: filename}
         self._add_more_vars(kw,logger)
-        if logger is not None:
-            for k,v in kw.items():
-                self.info('Set %s=%s'%(k,repr(v)),logger)
+        self._log_kw(kw, logger)
         if self.filename_arg:
             runner=runner[filename]
         runner=runner.env(**kw)
diff --git a/produtil/mpi_impl/srun.py b/produtil/mpi_impl/srun.py
index f2b9a54375..c3574ab1ee 100644
--- a/produtil/mpi_impl/srun.py
+++ b/produtil/mpi_impl/srun.py
@@ -59,9 +59,7 @@ def runsync(self,logger=None):
         """!Runs the "sync" command as an exe()."""
         if logger is None: logger=self.logger
         sync=produtil.prog.Runner(['/bin/sync'])
-        p=produtil.pipeline.Pipeline(sync,capture=True,logger=logger)
-        version=p.to_string()
-        status=p.poll()
+        produtil.pipeline.Pipeline(sync,capture=True,logger=logger)
 
     def openmp(self,arg,threads):
         """!Adds OpenMP support to the provided object
@@ -112,16 +110,15 @@ def _get_available_nodes(self):
         p=produtil.pipeline.Pipeline(
             scontrol,capture=True,logger=self.logger)
         nodelist=p.to_string()
-        status=p.poll()
         for line in nodelist.splitlines():
             node=line.strip()
-            if not node: next
-            if node in nodeset: next
+            if not node: continue
+            if node in nodeset: continue
             nodeset.add(node)
             available_nodes.append(node)
         return available_nodes
     
-    def mpirunner_impl(self,arg,allranks=False,rewrite_nodefile=True,**kwargs):
+    def mpirunner_impl(self,arg,allranks=False,rewrite_nodefile=True,label_io=False,**kwargs):
         """!This is the underlying implementation of mpirunner and should
         not be called directly."""
         assert(isinstance(arg,produtil.mpiprog.MPIRanksBase))
@@ -138,6 +135,9 @@ def mpirunner_impl(self,arg,allranks=False,rewrite_nodefile=True,**kwargs):
 
 
         srun_args=[self.srun_path,'--export=ALL','--cpu_bind=core']
+
+        if label_io:
+            srun_args.append('--label')
     
         if arg.nranks()==1 and allranks:
             srun_args.append('--distribution=block:block')
@@ -169,11 +169,11 @@ def mpirunner_impl(self,arg,allranks=False,rewrite_nodefile=True,**kwargs):
                 remaining_nodes=list(available_nodes)
 
             for rank,count in arg.expand_iter(expand=False):
-                if count<1: next
+                if count<1: continue
                 cmdfile.append('%d-%d %s'%(irank,irank+count-1,rank.to_shell()))
                 irank+=count
                 if rewrite_nodefile:
-                    rpn=max(min(node_size,rank.rpn()),1)
+                    rpn=max(min(node_size,rank.ranks_per_node),1)
                     need_nodes=max(1,(count+rpn-1)//rpn)
                     if need_nodes>len(remaining_nodes):
                         raise MPITooManyRanks('Request is too large for %d nodes of size %d: %s'%(
diff --git a/produtil/mpiprog.py b/produtil/mpiprog.py
index a7e5aa717d..e7adf6e1f4 100644
--- a/produtil/mpiprog.py
+++ b/produtil/mpiprog.py
@@ -84,6 +84,12 @@ class MixedValuesError(MPIProgSyntaxError):
 # mpi ranks.
 MIXED_VALUES=MixedValues()
 
+# constant string to pass to turbomode property
+TURBO_MODE_STR = "Turbo mode setting for this group of MPI ranks."
+
+# constant string to pass to threads property
+NUM_THREADS_STR = 'The number of threads per rank.'
+
 ########################################################################
 
 class MPIRanksBase(object):
@@ -157,7 +163,7 @@ def to_arglist(self,to_shell=False,expand=False,shell_validate=None,
         for rank,count in self.expand_iter(bool(expand)):
             assert(isinstance(rank,MPIRanksBase))
             assert(isinstance(count,int))
-            if not count>0:
+            if count<=0:
                 continue
             if first:
                 first=False
@@ -269,11 +275,10 @@ def setturbomode(self,tm):
         logging.getLogger('mpiprog.py').info(
             "TURBO MODE IS %s"%(repr(self._turbomode)))
         return self
-    def delturbomode(self,tm):
+    def delturbomode(self):
         """!Removes the request for turbo mode to be on or off."""
         self._turbomode=None
-    turbomode=property(getturbomode,setturbomode,delturbomode,
-                       "Turbo mode setting for this group of MPI ranks.")
+    turbomode=property(getturbomode,setturbomode,delturbomode,TURBO_MODE_STR)
 
     def turbo(self,flag=True):
         self.turbomode=flag
@@ -313,7 +318,7 @@ def setranks_per_node(self,rpn):
         """!Sets the number of MPI ranks per node requsted by this
         MPI rank."""
         rpn=int(rpn)
-        if not rpn>=0:
+        if rpn<0:
             raise ValueError('Ranks per node must be >=0 not %d'%rpn)
         self._ranks_per_node=rpn
 
@@ -379,7 +384,7 @@ def delthreads(self):
         """!Removes the request for threads."""
         for r,c in self.groups():
             del r.threads
-    threads=property(getthreads,setthreads,delthreads,"""The number of threads per rank.""")
+    threads=property(getthreads,setthreads,delthreads, NUM_THREADS_STR)
 
     def __mul__(self,factor):
         """!Returns a new set of MPI ranks that consist of this group
@@ -506,8 +511,7 @@ def delturbomode(self):
         del self._mpirank.turbomode
         self._turbomode=None
         return None
-    turbomode=property(getturbomode,setturbomode,delturbomode,
-                       "Turbo mode setting for this group of MPI ranks.")
+    turbomode=property(getturbomode,setturbomode,delturbomode, TURBO_MODE_STR)
     def setlocalopts(self,localopts):
         self._localopts=[ x for x in localopts ]
         self._mpirank.setlocalopts(localopts)
@@ -528,18 +532,6 @@ def __repr__(self):
         """!Returns "X*N" where X is the MPI program and N is the
         number of ranks."""
         return '%s*%d'%(repr(self._mpirank),int(self._count))
-        # sio=io.StringIO()
-        # sio.write(repr(self._mpirank))
-        # if self.haslocalopts():
-        #     sio.write('.setlocalopts(%s)'%(repr(self.localopts),))
-        # if self.threads:
-        #     sio.write('.threads(%s)'%(repr(self.threads),))
-        # if self.turbomode:
-        #     sio.write('.turbomode(%s)'%(repr(self.turbomode),))
-        # sio.write('*%d'%int(self._count))
-        # ret=sio.getvalue()
-        # sio.close()
-        # return ret
     def ngroups(self):
         """!Returns 1 or 0: 1 if there are ranks and 0 if there are none."""
         if self._count>0:
@@ -563,7 +555,7 @@ def copy(self):
     def ranks(self):
         """!Iterates over MPI ranks within self."""
         if self._count>0:
-            for i in range(self._count):
+            for _ in range(self._count):
                 yield self._mpirank
     def nranks(self):
         """!Returns the number of ranks this program requests."""
@@ -595,7 +587,7 @@ def __add__(self,other):
            self.ranks_per_node==other.ranks_per_node:
             copy=True
             for mpirank,count in other.groups():
-                if not mpirank==self._mpirank:
+                if mpirank!=self._mpirank:
                     copy=False
                     break
         if copy:
@@ -658,8 +650,7 @@ def delturbomode(self):
             del r.turbomode
         self._turbomode=None
         return None
-    turbomode=property(getturbomode,setturbomode,delturbomode,
-                       "Turbo mode setting for this group of MPI ranks.")
+    turbomode=property(getturbomode,setturbomode,delturbomode, TURBO_MODE_STR)
 
     def setthreads(self,threads):
         for r in self._el:
@@ -674,7 +665,7 @@ def getthreads(self):
     def delthreads(self):
         for r in self._el:
             del r.threads
-    threads=property(getthreads,setthreads,delthreads,"""The number of threads per rank.""")
+    threads=property(getthreads,setthreads,delthreads, NUM_THREADS_STR)
 
     def setranks_per_node(self,tm):
         t=bool(tm)
@@ -876,7 +867,7 @@ def setthreads(self,nthreads):
     def delthreads(self):
         """!Removes the request for threads."""
         self._threads=1
-    threads=property(getthreads,setthreads,delthreads,"""The number of threads per rank.""")
+    threads=property(getthreads,setthreads,delthreads, NUM_THREADS_STR)
     def to_shell(self):
         """!Return a POSIX sh representation of this MPI rank, if
         possible."""
@@ -902,6 +893,8 @@ def __repr__(self):
             sio.write('.threads(%s)'%(repr(self.threads),))
         if self.turbomode:
             sio.write('.turbomode(%s)'%(repr(self.turbomode),))
+        if self.ranks_per_node:
+            sio.write('.rpn(%s)'%(repr(self.ranks_per_node),))
         ret=sio.getvalue()
         sio.close()
         return ret
@@ -1038,7 +1031,7 @@ def get_logger(self):
     @property
     def runner(self):
         return self._runner
-    def validate(self): 
+    def validate(self,more=None):
         """!Does nothing."""
     def __eq__(self,other):
         """!Returns True if other is an MPISerial with the same Runner,
@@ -1065,7 +1058,7 @@ def to_shell(self):
 ########################################################################
 
 def collapse(runner):
-    SPMDs=list()
+    spmds=list()
     rc=list()
     for rank,count in runner.expand_iter(True):
         if not len(rc):
@@ -1077,11 +1070,11 @@ def collapse(runner):
             rc.append([rank,count])
             
     for rank,count in rc:
-        SPMDs.append(MPIRanksSPMD(rank,count))
+        spmds.append(MPIRanksSPMD(rank,count))
 
-    if len(SPMDs)>1:
-        result=MPIRanksMPMD(SPMDs)
+    if len(spmds)>1:
+        result=MPIRanksMPMD(spmds)
     else:
-        result=SPMDs[0]
+        result=spmds[0]
 
     return result
diff --git a/produtil/numerics.py b/produtil/numerics.py
index b5d64fd011..8139a5ee64 100644
--- a/produtil/numerics.py
+++ b/produtil/numerics.py
@@ -138,7 +138,7 @@ def great_arc_dist(xlon1,ylat1, xlon2,ylat2):
     @param xlon2,ylat2 second point, degrees
     @returns distance in meters"""
     deg2rad=math.pi/180.0
-    Requator=6378137.0
+    r_equator=6378137.0
     flattening_inv=298.247
 
     rlat1=float(ylat1)*deg2rad
@@ -146,10 +146,10 @@ def great_arc_dist(xlon1,ylat1, xlon2,ylat2):
     rlat2=float(ylat2)*deg2rad
     rlon2=float(xlon2)*deg2rad
 
-    Rearth1=Requator*(1.0-math.sin(rlat1)**2.0/flattening_inv)
-    Rearth2=Requator*(1.0-math.sin(rlat2)**2.0/flattening_inv)
+    r_earth1=r_equator*(1.0-math.sin(rlat1)**2.0/flattening_inv)
+    r_earth2=r_equator*(1.0-math.sin(rlat2)**2.0/flattening_inv)
 
-    return (Rearth1+Rearth2)*math.asin(min(1.0,math.sqrt( \
+    return (r_earth1+r_earth2)*math.asin(min(1.0,math.sqrt( \
         math.sin((rlat1-rlat2)/2.0)**2.0 + \
         math.cos(rlat1)*math.cos(rlat2)*math.sin((rlon1-rlon2)/2.0)**2.0)))
 
@@ -187,12 +187,12 @@ def randint_zeromean(count,imax,randomizer=None):
         randint=random.randint
     else:
         randint=randomizer.randint
-    if imax!=0 and not ( -imax < imax):
+    if imax!=0 and -imax >= imax:
         # Integer overflow
         raise OverflowError(
             'In randint_zeromean, imax=%d cannot be negated and fit '
             'within a Python int.'%imax)
-    rand=[ randint(-imax,imax) for x in range(count) ]
+    rand=[ randint(-imax,imax) for _ in range(count) ]
     cen=sum(rand)
     while cen!=0:
         if cen>0:
@@ -417,31 +417,26 @@ def to_timedelta(a,b=None,negok=True):
     if isinstance(a,datetime.timedelta): return a
     if isinstance(a,str) and b is None:
         # 03:14 = three hours
-        try:
-            m=re.search(r'''(?ix) \A \s* (?P<negative>-)? 0* (?P<hours>\d+)
-                :0*(?P<minutes>\d+)
-                  (?: :0*(?P<seconds>\d+(?:\.\d*)?) )?
-                \s*''', a)
-            if m:
-                (hours,minutes,seconds)=(0.,0.,0.)
-                mdict=m.groupdict()
-                if 'hours' in mdict and mdict['hours'] is not None:
-                    hours=float(mdict['hours'])
-                if 'minutes' in mdict and mdict['minutes'] is not None:
-                    minutes=float(mdict['minutes'])
-                if 'seconds' in  mdict and mdict['seconds'] is not None:
-                    seconds=float(mdict['seconds'])
-                dt=datetime.timedelta(hours=hours,minutes=minutes,
-                                      seconds=seconds)
-                if 'negative' in mdict and mdict['negative'] is not None \
-                        and mdict['negative']=='-':
-                    return -dt
-                return dt
-        except(TypeError,ValueError,AttributeError) as e:
-            # Fall back to to_fraction
-            raise #FIXME: remove this line?  Why is this here?  It
-                  #conflicts with the description.
-            pass
+        m=re.search(r'''(?ix) \A \s* (?P<negative>-)? 0* (?P<hours>\d+)
+            :0*(?P<minutes>\d+)
+              (?: :0*(?P<seconds>\d+(?:\.\d*)?) )?
+            \s*''', a)
+        if m:
+            (hours,minutes,seconds)=(0.,0.,0.)
+            mdict=m.groupdict()
+            if 'hours' in mdict and mdict['hours'] is not None:
+                hours=float(mdict['hours'])
+            if 'minutes' in mdict and mdict['minutes'] is not None:
+                minutes=float(mdict['minutes'])
+            if 'seconds' in  mdict and mdict['seconds'] is not None:
+                seconds=float(mdict['seconds'])
+            dt=datetime.timedelta(hours=hours,minutes=minutes,
+                                  seconds=seconds)
+            if 'negative' in mdict and mdict['negative'] is not None \
+                    and mdict['negative']=='-':
+                return -dt
+            return dt
+
     f=to_fraction(a,b,negok=negok)
     (fpart,ipart)=math.modf(f)
     return datetime.timedelta(seconds=ipart,
@@ -562,7 +557,7 @@ def __init__(self,times,init=None):
             self._data=[None]*N
         else:
             self._assigned=[True]*N
-            self._data=[init() for x in range(N)]
+            self._data=[init() for _ in range(N)]
     def at_index(self,index):
         """!Returns the data at the given index, or raises KeyError if
         no data exists.
@@ -604,17 +599,14 @@ def neartime(self,when,epsilon=None):
         value.
         @param when the time of interest"""
         (then,index)=self.index_of(when)
-        if epsilon is not None:
-            if abs(to_fraction(then-when,negok=True)) \
-                    <= to_fraction(epsilon):
-                return then
-            else:
-                raise NoNearbyValues(
-                    '%s: nearest value not after is %s, which is not '
-                    'within %s seconds.'%(str(when),str(then),
-                                          str(to_fraction(epsilon))))
-        else:
-            return then
+        if (epsilon is not None and
+                not abs(to_fraction(then-when,negok=True))
+                <= to_fraction(epsilon)):
+            raise NoNearbyValues(
+                '%s: nearest value not after is %s, which is not '
+                'within %s seconds.'%(str(when),str(then),
+                                      str(to_fraction(epsilon))))
+        return then
     def get(self,when,default):
         """!Returns the item at the latest time that is not later than
         "when."  
@@ -686,7 +678,7 @@ def __contains__(self,when):
         try:
             (iwhen,index)=self.index_of(when)
             return self._assigned[index]
-        except hwrf.exceptions.NotInTimespan as KeyError:
+        except hwrf.exceptions.NotInTimespan:
             return False
     def __len__(self):
         """!Returns the number of times that have data."""
@@ -772,10 +764,6 @@ def index_of(self,when):
                 ('%s: not in range [%s,%s]' % (when.ctime(),
                     self._start.ctime(),self._end.ctime()) )
         return (self._times[index],index)
-    # def __iter__(self):
-    #     """Iterates over all known times."""
-    #     for i in range(len(self._times)):
-    #         yield self._times[i]
 
 ########################################################################
 
@@ -835,7 +823,7 @@ def index_of(self,when):
             imiddle=(iearly+ilate)/2
             middle=self._times[imiddle]
             if when<middle:
-                (ilate,late)=(imiddle,middle)
+                (ilate,_)=(imiddle,middle)
             else:
-                (iearly,early)=(imiddle,middle)
+                (iearly,_)=(imiddle,middle)
         return ( self._times[iearly], iearly )
diff --git a/produtil/pipeline.py b/produtil/pipeline.py
index 11202a2460..af219fb060 100755
--- a/produtil/pipeline.py
+++ b/produtil/pipeline.py
@@ -120,7 +120,7 @@ def pclose(i):
     with plock:
         try:
             os.close(i)
-        except EnvironmentError as e: pass
+        except EnvironmentError: pass
         if i in pipes_to_close: 
             pipes_to_close.remove(i)
 
@@ -161,32 +161,32 @@ def launch(cmd, env=None, stdin=None, stdout=None, stderr=None,
         raise ValueError(
             "In produtil.pipeline.launch, cd must not be the empty string.")
 
-    stdinP=None    ;   stdinC=None
-    stdoutP=None   ;   stdoutC=None
-    stderrP=None   ;   stderrC=None
+    stdin_p=None    ;   stdin_c=None
+    stdout_p=None   ;   stdout_c=None
+    stderr_p=None   ;   stderr_c=None
     logger=logging.getLogger(cmd[0])
     global pipes_to_close
     if debug:
         logger.debug("Start %s"%(repr(cmd),))
 
     if stdin is PIPE:
-        (stdinC,stdinP)=pipe(logger)
+        (stdin_c,stdin_p)=pipe(logger)
         if debug: 
-            logger.debug("Pipe for stdin: %d<==%d"%(stdinC,stdinP))
+            logger.debug("Pipe for stdin: %d<==%d"%(stdin_c,stdin_p))
     else:
-        stdinC=stdin
+        stdin_c=stdin
     if stdout is PIPE:
-        (stdoutP,stdoutC)=pipe(logger)
+        (stdout_p,stdout_c)=pipe(logger)
         if debug: 
-            logger.debug("Pipe for stdout: %d<==%d"%(stdoutP,stdoutC))
+            logger.debug("Pipe for stdout: %d<==%d"%(stdout_p,stdout_c))
     else:
-        stdoutC=stdout
+        stdout_c=stdout
     if stderr is PIPE:
-        (stderrP,stderrC)=pipe(logger)
+        (stderr_p,stderr_c)=pipe(logger)
         if debug: 
-            logger.debug("Pipe for stderr: %d<==%d"%(stderrP,stderrC))
+            logger.debug("Pipe for stderr: %d<==%d"%(stderr_p,stderr_c))
     elif stderr is not ERR2OUT:
-        stderrC=stderr
+        stderr_c=stderr
 
     pid=os.fork()
     assert(pid>=0)
@@ -196,33 +196,33 @@ def launch(cmd, env=None, stdin=None, stdout=None, stderr=None,
             if debug:
                 logger.debug("Close stdin %d on parent."%stdin)
             pclose(stdin)
-        if stdin is PIPE and stdinC is not None:
+        if stdin is PIPE and stdin_c is not None:
             if debug:
-                logger.debug("Close stdinC %d on parent."%stdinC)
-            pclose(stdinC)
-            padd(stdinP)
+                logger.debug("Close stdin_c %d on parent."%stdin_c)
+            pclose(stdin_c)
+            padd(stdin_p)
         if stdout is not None and stdout is not PIPE:
             if debug:
                 logger.debug("Close stdout %d on parent."%stdout)
             pclose(stdout)
-        if stdout is PIPE and stdoutC is not None:
+        if stdout is PIPE and stdout_c is not None:
             if debug:
-                logger.debug("Close stdoutC %d on parent."%stdoutC)
-            pclose(stdoutC)
-            padd(stdoutP)
+                logger.debug("Close stdout_c %d on parent."%stdout_c)
+            pclose(stdout_c)
+            padd(stdout_p)
         if stderr is not None and stderr is not PIPE and stderr is not ERR2OUT:
             if debug:
                 logger.debug("Close stderr %d on parent."%stderr)
             pclose(stderr)
-        if stderr is PIPE and stderrC is not None:
+        if stderr is PIPE and stderr_c is not None:
             if debug:
-                logger.debug("Close stderrC %d on parent."%stderrC)
-            pclose(stderrC)
-            padd(stderrP)
+                logger.debug("Close stderr_c %d on parent."%stderr_c)
+            pclose(stderr_c)
+            padd(stderr_p)
         if debug:
             logger.debug("On parent, returning %s"%(
-                    repr((pid, stdinP,stdoutP,stderrP))))
-        return (pid, stdinP,stdoutP,stderrP)
+                    repr((pid, stdin_p,stdout_p,stderr_p))))
+        return (pid, stdin_p,stdout_p,stderr_p)
 
     if isinstance(cd,str):
         os.chdir(cd)
@@ -230,39 +230,39 @@ def launch(cmd, env=None, stdin=None, stdout=None, stderr=None,
     # We are in the child process
     pclose_all(i=stdin,o=stdout,e=stderr)
 
-    if stdinP is not None:
+    if stdin_p is not None:
         if debug:
-            logger.debug("Close stdinP %d on child."%stdinP)
-        pclose(stdinP)
-    if stdinC is not None:
+            logger.debug("Close stdin_p %d on child."%stdin_p)
+        pclose(stdin_p)
+    if stdin_c is not None:
         if debug:
-            logger.debug("Point stdin to stdinC %d on child and close original."%stdinC)
-        os.dup2(stdinC,0)
-        pclose(stdinC)
+            logger.debug("Point stdin to stdin_c %d on child and close original."%stdin_c)
+        os.dup2(stdin_c,0)
+        pclose(stdin_c)
 
-    if stdoutP is not None:
+    if stdout_p is not None:
         if debug:
-            logger.debug("Close stdoutP %d on child."%stdoutP)
-        pclose(stdoutP)
-    if stdoutC is not None:
+            logger.debug("Close stdout_p %d on child."%stdout_p)
+        pclose(stdout_p)
+    if stdout_c is not None:
         if debug:
-            logger.debug("Point stdout to stdoutC %d on child and close original."%stdoutC)
-        os.dup2(stdoutC,1)
-        pclose(stdoutC)
+            logger.debug("Point stdout to stdout_c %d on child and close original."%stdout_c)
+        os.dup2(stdout_c,1)
+        pclose(stdout_c)
 
     if stderr is ERR2OUT:
         if debug:
             logger.debug("Redirect stderr to stdout on child.")
         os.dup2(1,2)
-    if stderrP is not None:
+    if stderr_p is not None:
         if debug:
-            logger.debug("Close stderrP %d on child."%stderrP)
-        pclose(stderrP)
-    if stderrC is not None:
+            logger.debug("Close stderr_p %d on child."%stderr_p)
+        pclose(stderr_p)
+    if stderr_c is not None:
         if debug:
-            logger.debug("Point stderr to stderrC %d on child and close original."%stderrC)
-        os.dup2(stderrC,2)
-        pclose(stderrC)
+            logger.debug("Point stderr to stderr_c %d on child and close original."%stderr_c)
+        os.dup2(stderr_c,2)
+        pclose(stderr_c)
 
     if debug:
         logger.debug("Reset signal handlers on child.")
@@ -312,11 +312,11 @@ def kill_for_thread(th):
     for p in killme:
         try:
             os.kill(p,signal.SIGTERM)
-        except EnvironmentError as e:
+        except EnvironmentError:
             pass
         try:
             _manage_set[th].remove(killme)
-        except (ValueError,KeyError,TypeError) as e:
+        except (ValueError,KeyError,TypeError):
             pass
 
 def kill_all():
@@ -559,10 +559,10 @@ def manage(proclist,inf=None,outf=None,errf=None,instr=None,logger=None,
 
 def simple_run(cmd, env=None, stdin=None, stdout=None, stderr=None, 
                debug=False, cd=None, logger=None, binary=False):
-    (pid, stdinP, stdoutP, stderrP) = launch(
+    (pid, stdin_p, stdout_p, stderr_p) = launch(
         cmd,env,stdin,stdout,stderr,debug,cd)
     (outstder, errstr, done) = \
-      manage([pid], inf=stdinP, outf=stdoutP, errf=stderrP, logger=logger, 
+      manage([pid], inf=stdin_p, outf=stdout_p, errf=stderr_p, logger=logger,
              binary=binary )
     result=done[pid][1]
     if os.WIFEXITED(result):
@@ -653,7 +653,7 @@ def send_signal(self,sig):
         for p in self.__children:
             try:
                 os.kill(p,sig)
-            except EnvironmentError as e: pass
+            except EnvironmentError: pass
 
     def terminate(self):
         """!Sends SIGTERM to all children."""
@@ -662,11 +662,6 @@ def kill(self):
         """!Sends SIGKILL to all children."""
         self.send_signal(signal.SIGKILL)
 
-    # def __repr__(self):
-    #     """Does not run the pipeline; simply returns <Pipeline at XX>
-    #     where XX is the id of this object."""
-    #     return '<Pipeline at 0x%x>'%(id(self),)
-
     def communicate(self,sleeptime=None):
         """!Writes to input, reads from output, waits for child
         processes, etc.  This is just a wrapper around the manage()
diff --git a/produtil/prog.py b/produtil/prog.py
index 839899bdb5..f6f2c6fdfc 100644
--- a/produtil/prog.py
+++ b/produtil/prog.py
@@ -43,6 +43,8 @@
 import produtil.mpi_impl
 from produtil.pipeline import launch, manage, PIPE, ERR2OUT
 
+ERR2OUT_FCT_STR = '.err2out()'
+
 class ProgSyntaxError(Exception): 
     """!Base class of exceptions raised when a Runner is given
     arguments that make no sense."""
@@ -140,7 +142,7 @@ def shvarok(s):
     """!Returns True if the specified environment variable name is a
     valid POSIX sh variable name, and False otherwise.
     @param s an environment variable name"""
-    if re.search(r'\A[A-Za-z][A-Za-z0-9_]*\z',s):
+    if re.search(r'\A[A-Za-z]\w*\z',s):
         return True
     else:
         return False
@@ -337,12 +339,12 @@ def _gen_stream(self):
         return (None,None,ERR2OUT,False)
     def repr_for_in(self):   
         """!This should never be called.  It returns ".err2out()"."""
-        return '.err2out()'
+        return ERR2OUT_FCT_STR
     def repr_for_out(self):  
         """!Part of the representation of Runner.__repr__.  Returns
         ".err2out()" which instructs a Runner to send stderr to
         stdout."""
-        return '.err2out()'
+        return ERR2OUT_FCT_STR
     def __eq__(self,other):  
         """!Is the other object an OutIsError?
         @param other the other object to analyze."""
@@ -568,7 +570,7 @@ def __repr__(self):
             s+='.out(%s)'%(self._stdout.repr_for_out(),)
         if self._stderr is not None:
             if isinstance(self._stderr,OutIsError):
-                s+='.err2out()'
+                s+=ERR2OUT_FCT_STR
             else:
                 s+='.err(%s)'%(self._stderr.repr_for_err(),)
         if not self._copy_env:
@@ -796,7 +798,7 @@ def to_shell(self):
                 s+=' '+shbackslash("%s=%s"%(key,self._env[key]))
             if not self._copy_env:
                 for key in ('PATH','USER','LOGNAME','HOME'):
-                    if not key in self._env:
+                    if key not in self._env:
                         s+=' "%s=$%s"'%(key,key)
             s+=' '
         s+=' '.join([shbackslash(x) for x in self._args])
diff --git a/produtil/retry.py b/produtil/retry.py
index ce37571fd4..952fa40ccd 100644
--- a/produtil/retry.py
+++ b/produtil/retry.py
@@ -48,8 +48,7 @@ def retry_io(max_tries,sleep_time,operation,opargs=[],logger=None,
     if fail is not None:
         if failargs is None: failargs=opargs
         if giveup is None: giveup=fail
-    if giveup is not None:
-        if giveupargs is None: giveupargs=failargs
+    if giveup is not None and giveupargs is None: giveupargs=failargs
 
     if sleep_time is None:
         sleep_time=0.1
@@ -66,11 +65,10 @@ def retry_io(max_tries,sleep_time,operation,opargs=[],logger=None,
                 if logger is not None:
                     logger.debug('Failed but have not given up: %s'%(str(e),),
                                  exc_info=True)
-                if sleep_time is not None:
-                    if randsleep:
-                        sleepmax=min(sleep_time,0.05) * \
-                            min(max(1.0,backoff**ntry),50.0)
-                        sleepme=random.uniform(sleepmax/2.0,sleepmax)
+                if sleep_time is not None and randsleep:
+                    sleepmax=min(sleep_time,0.05) * \
+                        min(max(1.0,backoff**ntry),50.0)
+                    sleepme=random.uniform(sleepmax/2.0,sleepmax)
                 if isinstance(fail,str):
                     if logger is not None and ntry>=first_warn:
                         logger.info("%s (try %d/%d; sleep %.3f and retry): %s"%\
diff --git a/produtil/run.py b/produtil/run.py
index 4f48cc523a..a7e469b890 100644
--- a/produtil/run.py
+++ b/produtil/run.py
@@ -464,9 +464,9 @@ def checkrun(arg,logger=None,**kwargs):
     list of acceptable exit statuses."""
     r=run(arg,logger=logger)
     if kwargs is not None and 'ret' in kwargs:
-        if not r in kwargs['ret']:
+        if r not in kwargs['ret']:
             raise ExitStatusException('%s: unexpected exit status'%(repr(arg),),r)
-    elif not r==0:
+    elif r!=0:
         raise ExitStatusException('%s: non-zero exit status'%(repr(arg),),r)
     return r
 
@@ -516,9 +516,9 @@ def runstr(arg,logger=None,**kwargs):
     s=p.to_string()
     r=p.poll()
     if kwargs is not None and 'ret' in kwargs:
-        if not r in kwargs['ret']:
+        if r not in kwargs['ret']:
             raise ExitStatusException('%s: unexpected exit status'%(repr(arg),),r)
-    elif not r==0:
+    elif r!=0:
         raise ExitStatusException('%s: non-zero exit status'%(repr(arg),),r)
     return s
 
diff --git a/produtil/testing/__init__.py b/produtil/testing/__init__.py
deleted file mode 100644
index 59c6074a83..0000000000
--- a/produtil/testing/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-##@namespace produtil.testing
-# Test suite automation utilities.
-#
-# The produtil.testing package contains a system that automates
-# testing of a suite of programs.  This is intended to be used for
-# regression testing, not large-scale retrospective science tests.
-#
-# The produtil.testing suite has its own test description language.  A
-# parser, produtil.testing.parse, parses this into an object tree.  A
-# set of compilers (produtil.testing.rocoto and
-# produtil.testing.script) compiles the object tree into a script or
-# set of scripts for testing.
diff --git a/produtil/testing/parse.py b/produtil/testing/parse.py
deleted file mode 100644
index 92644dfc9f..0000000000
--- a/produtil/testing/parse.py
+++ /dev/null
@@ -1,1434 +0,0 @@
-##@namespace produtil.testing.parse
-# This module contains the parser for the produtil.testing test suite.  
-#
-# The main interface to the produtil.testing parser is
-# produtil.testing.parse.Parser.parse().  It constructs an internal
-# tree representation of a file, provided by the
-# produtil.testing.tokenizer.Tokenizer.  The tree can then be
-# converted to a workflow by produtil.testing.rocoto or
-# produtil.testing.script.
-
-import sys, re, io, collections, os, datetime, logging, math
-import produtil.run, produtil.log, produtil.setup
-
-# This module really does use everything public from utilities,
-# parsetree and tokenize, hence the "import *"
-from produtil.testing.utilities import *
-from produtil.testing.parsetree import *
-from produtil.testing.tokenize import *
-
-from produtil.testing.setarith import arithparse
-
-__all__=[ 'Parser' ]
-
-########################################################################
-
-class RunConPair(object):
-    """!A tuple-like object of a runnable object and a
-    produtil.testing.parsetree.Context.  This is used to store
-    something that can be run, such as a compilation command or batch
-    job, and the context from which its execution was requested."""
-    def __init__(self,runnable,context):
-        """!Constructor for RunConPair
-
-        @param runnable  The runnable object for self.runnable
-        @param context   The produtil.testing.parsetree.Context for self.context"""
-        self.runnable=runnable
-        self.context=context
-        self.__requested_platform=None
-
-    def set_requested_platform_name(self,platform):
-        self.__requested_platform_name=str(platform)
-    def get_requested_platform_name(self):
-        return self.__requested_platform_name
-    def del_requested_platform_name(self):
-        self.__requested_platform=None
-    requested_platform_name=property(get_requested_platform_name,
-                                     set_requested_platform_name,
-                                     del_requested_platform_name)
-
-    @property
-    def as_tuple(self):
-        """!A tuple self.runnable,self.context"""
-        return self.runnable,self.context
-    def __iter__(self):
-        yield self.runnable
-        yield self.context
-    def __hash__(self):
-        return hash(self.runnable)
-    def __eq__(self,other):
-        if not isinstance(other,RunConPair):
-            return self.runnable==other
-        return self.runnable==other.runnable
-
-    # Replacements for __cmp__:
-    def __lt__(self,other):
-        if not isinstance(other,RunConPair):
-            return self.runnable<other
-        return self.runnable<other.runnable
-    def __gt__(self,other):
-        if not isinstance(other,RunConPair):
-            return self.runnable>other
-        return self.runnable>other.runnable
-    def __ne__(self,other):
-        return not ( self == other )
-    def __ge__(self,other):
-        return self>other or self==other
-    def __le__(self,other):
-        return self<other or self==other
-
-    def oldcmp(self,other):
-        if not isinstance(other,RunConPair):
-            return self.runnable.oldcmp(other)
-        return self.runnable.oldcmp(other.runnable)
-
-    ##@property as_tuple
-    # A tuple containing the runnable and context
-    #
-    # Same as:
-    # @code
-    #   (self.runnable,self.context)
-    # @endcode
-
-    ##@var runnable
-    # The first element of this RunConPair: a runnable object
-
-    ##@var context
-    # The second element of this RunConPair: a produtil.testing.parsetree.Context
-
-class Parser(object):
-    """!Parser for the produtil.testing suite."""
-    def __init__(self,run_mode=None,logger=None,verbose=True):
-        """!Constructor for the Parser
-
-        @param run_mode produtil.testing.utilities.EXECUTION to
-            execute and verify results, or
-            produtil.testing.utilities.BASELINE to generate a new
-            baseline.
-        @param logger a logging.Logger for logging messages, such as
-            syntax errors
-        @param verbose Increased verbosity flag: True = more verbose.
-            """
-        super(Parser,self).__init__()
-        if logger is None: logger=module_logger
-        if run_mode is None: run_mode=EXECUTION
-        if run_mode is not EXECUTION and run_mode is not BASELINE:
-            raise ValueError(
-                'The Parser.__init__ run_mode argument must be the '
-                'special module constants EXECUTION or BASELINE.')
-        self.__runsets=collections.defaultdict(ListableSet)
-        self.__runobjs=dict()
-        self.__run_mode=run_mode
-        self.__logger=logger
-        self.__verbose=bool(verbose)
-
-    ##@property run_mode
-    # Returns the run mode: produtil.testing.utilities.EXECUTION or
-    # produtil.testing.utilities.BASELINE
-
-    @property
-    def run_mode(self):
-        """!Returns the run mode: produtil.testing.utilities.EXECUTION
-        or produtil.testing.utilities.BASELINE"""
-        return self.__run_mode
-
-    ##@property verbose
-    # Verbosity flag: True for verbose logging, False for quiet mode
-
-    @property
-    def verbose(self):
-        """!Verbosity flag"""
-        return self.__verbose
-
-    ##@property logger
-    # The logging.Logger to log messages
-
-    @property
-    def logger(self):
-        """!The logging.Logger to log messages"""
-        return self.__logger
-
-    ##@property allset
-    # Returns the special "**all**" runset, which contains all
-    # runnables that had an explicit run statement.
-
-    @property
-    def allset(self):
-        """!Returns the special "**all**" runset, which contains all
-        runnables that had an explicit run statement."""
-        return self.__runsets['**all**']
-
-    def setarith(self,expr=None):
-        """!Executes the specified expression via the setarith module,
-        returning the resulting runset as a ListableSet.
-        Automatically resolves dependencies."""
-        if not expr:
-            runme=ListableSet(self.allset)
-        else:
-            runme=arithparse(expr,self.__runsets,self.__runobjs)
-
-        result=ListableSet()
-        processed=set()
-        for runcon in runme:
-            self._resolve_deps_impl(result,processed,runcon)
-        return result
-    def iterrun(self,runset='**all**'):
-        """!Iterates over all runnables in the runset.  
-
-        @param runset The runset of interest.  If no runset is
-        specified then the special "**all**" runset is used, which
-        contains all runnables that had a "run" command, plus
-        dependencies."""
-        runset=runset or '**all**'
-        for runcon in self.__runsets[runset]:
-            yield runcon
-    def itersets(self):
-        """"!Iterates over all runset names in self, including the
-        special "**all**" set, which contains all runnables that had a
-        "run" command, plus dependencies."""
-        for setname,runset in self.__runsets.items():
-            yield setname,runset
-    def con(self,token=None,scopes=None):
-        """!Returns a context for the given token and scope.  
-
-        @param token Used to determine the file and line number.  If
-        the token is None, then a fileless context is used.  This
-        indicates the context is not from any file or line.
-
-        @param scope the list of Scopes.  If none are given, then an
-        empty list is used.  This indicates the scope is from outside
-        the parsed text entirely.
-
-        @returns a produtil.testing.parsetree.Context for the given
-        token and scope, or a fileless context if no token is
-        provided."""
-        if scopes is None: scopes=[]
-        if token is None:
-            return produtil.testing.parsetree.fileless_context(
-                scopes=scopes,verbose=self.verbose)
-        return Context(scopes,token,self.__run_mode,self.__logger,
-                       verbose=self.verbose)
-    def add_run(self,runset,runme,con):
-        """!Adds another runnable object to execute in a given runset
-
-        Updates the internal bookkeeping to indicate the given
-        runnable object can be run.  If a runset is provided, then the
-        set with the given name is updated to indicate it can run the
-        object.  Regardless of runset, the special "**all**" set is
-        updated to run the given runnable.  If the set already
-        contains runme, adding it again has no effect.
-
-        @param runset The set of"""
-        if not isinstance(runme,Task) and not isinstance(runme,Test):
-            raise TypeError(
-                'The runme argument to add_run must be a Test or Task '
-                '(in produtil.testing.parsetree) or subclass.  You '
-                'provided a %s %s'%(
-                    type(runme).__name__,elipses(repr(runme))))
-        if runset is None:
-            self.__runobjs[runme.name]=RunConPair(runme,con)
-            return
-        addme=RunConPair(runme,con)
-        for xrunset in [ runset, '**all**' ]:
-            self.__runsets[xrunset].add(addme)
-    def _resolve_deps_impl(self,newset,processed,runcon):
-        """!Adds a runnable object and its dependencies to a list of
-        objects to run.
-
-        Adds runcon to the processed set to mark that it is being
-        processed, returning immediately if it was already there.
-        Then recurses into each dependency of runcon, calling this
-        function on each, and then adds runcon to newset.  The result
-        is that the newset will contain all runnable objects in
-        correct dependency order.
-        
-        @param newset The ListableSet to receive the runnable objects
-        @param processed a set of all runnable objects already
-        processed or being processed by recursive calls to this
-        function. 
-        @param runcon The runnable object to process, a RunConPair
-        @returns None"""
-        if not isinstance(runcon,RunConPair):
-            raise TypeError('In _resolve_deps_impl, runcon must be a RunConPair, not a %s %s'%(type(runcon).__name__,elipses(repr(runcon))))
-        assert(isinstance(runcon,RunConPair))
-        assert(isinstance(newset,ListableSet))
-        if runcon in processed: return
-        processed.add(runcon)
-        for prereq in runcon.runnable.iterdeps():
-            if prereq not in newset:
-                self._resolve_deps_impl(
-                    newset,processed,RunConPair(prereq,runcon.context))
-        newset.add(runcon)
-    def resolve_deps(self):
-        """!Resolves dependencies in the runsets, replacing them with
-        new runsets that contain all dependencies and have runnables
-        listed in correct dependency order.
-        @returns None"""
-        newrunsets=dict()
-        for setname in self.__runsets.keys():
-            processed=set()
-            newset=ListableSet()
-            for runcon in self.__runsets[setname]:
-                assert(isinstance(runcon,RunConPair))
-                self._resolve_deps_impl(newset,processed,runcon)
-            newrunsets[setname]=newset
-        self.__runsets=newrunsets
-    def parse(self,tokenizer,scope=None,unique_id=None,morevars=None):
-        """!Main entry point for the parser.  Parses the stream of
-        tokens returned by the tokenizer.
-
-        @param tokenizer The produtil.testing.tokenize.Tokenizer that
-        returns a stream of tokens from some file or string
-
-        @param scope The innermost produtil.testing.parsetree.Scope.
-        If None, a new produtil.testing.parsetree.Scope is created.
-
-        @param unique_id The value for the special UNIQUE_ID global variable.
-
-        @param morevars A dict with additional variables to set in the
-        global scope."""
-        if scope is None:
-            scope=Scope()
-        if unique_id is None:
-            unique_id=os.getpid()
-        if morevars is not None:
-            for k,v in morevars.items():
-                scope.setlocal(str(k),String([scope],str(v),False))
-        if not isinstance(unique_id,int):
-            raise TypeError(
-                'The unique_id argument to Parser.parse() must be an '
-                'int, not a %s %s.'%( type(unique_id).__name__,
-                                      elipses(repr(unique_id)) ))
-        tokiter=peekable(tokenizer)
-        scope.setlocal('ENV',Environ())
-        assert(isinstance(unique_id,int))
-        scope.setlocal('UNIQUE_ID',Numeric(unique_id))
-        if self.run_mode==BASELINE:
-            scope.setlocal('RUN_MODE',String([scope],'BASELINE',False))
-        else:
-            scope.setlocal('RUN_MODE',String([scope],'EXECUTION',False))
-        result=self.parse_subscope(
-            tokiter,[scope],[end_of_text_type],
-            self.parse_between_assignments,
-            allow_overwrite=False,
-            allow_resolve=True,
-            allow_run=True,
-            allow_null=False,
-            allow_use=False,
-            allow_load=True,
-                scope_name='global scope')
-        self.resolve_deps()
-
-    def parse_between_arguments(self,tokiter,ends=None):
-        """!Used inside an argument list "function(arg,arg2,...)".
-        Skips over the "," and whitespace between arguments.
-
-        @param tokiter a peekable iterator that yields tokens
-        @param ends: optional; the termination token for the argument list. Default: ")" 
-        @return True if we are still inside the argument list, or False otherwise"""
-        if ends is None: ends=[')']
-        peek=tokiter.peek()
-        # yell('%-7s peek type=%s value=%s\n'%(
-        #         'BETWEEN',str(peek.token_type),elipses(str(
-        #                 peek.token_value))))
-        while True:
-            if peek.token_type == ',':
-                next(tokiter)
-                # yell('%-7s consume ,\n'%('BETWEEN',))
-                return True
-            elif peek.token_type in ends:
-                # yell('%-7s stop at %s\n'%('BETWEEN',peek.token_type))
-                return False
-            elif peek.token_type==end_of_line_type:
-                # yell('%-7s saw \n'%('BETWEEN',))
-                next(tokiter)
-                peek=tokiter.peek()
-            else:
-                return False
-    def skip_eoln(self,tokiter):
-        """!Skips over end-of-line characters.
-        @param tokiter a peekable iterator that yields tokens
-        @returns None"""
-        peek=tokiter.peek()
-        while peek.token_type==end_of_line_type:
-            next(tokiter)
-            peek=tokiter.peek()
-    def parse_between_assignments(self,tokiter):
-        """!Skips over characters between assignments in a scope ,;
-
-        Skips over , and ; between assignments.  Checks to see if the
-        assignment block ended by looking for end-of-line, end-of-text or }
-
-        @param tokiter a peekable iterator that yields tokens
-        @return True if any , ; } end-of-line or end-of-text were seen"""
-        peek=tokiter.peek()
-        seen=False
-        # yell('%-7s peek type=%s value=%s in parse_between_assignments\n'%(
-        #         'BETWEEN',str(peek.token_type),
-        #         elipses(str(peek.token_value))))
-        while True:
-            seen=True
-            if peek.token_type in [ ',', ';' ]:
-                next(tokiter)
-                # yell('%-7s consume %s\n'%('BETWEEN',peek.token_type))
-                return True
-            elif peek.token_type in [ '}', end_of_text_type ]:
-                # yell('%-7s stop at %s\n'%('BETWEEN',peek.token_type))
-                return True
-            elif peek.token_type==end_of_line_type:
-                # yell('%-7s saw %s\n'%('BETWEEN',repr(peek.token_type)))
-                seen=True
-                next(tokiter)
-                peek=tokiter.peek()
-            else:
-                break
-        return seen
-        self.error('between_assignments',peek)
-
-    def parse_embed_script(self,tokiter,scopes,ends,parse_between=None):
-        """!Parses an embedded script block.  Returns the resulting object.
-
-        @param tokiter a peekable iterator that yields tokens
-        @param scopes a list of nested scopes (innermost first) surrounding the embedded script block
-        @param ends termination tokens of the containing scope
-
-        @param parse_between an optional function that is called after
-        the embedded script block.  This skips over tokens between the
-        embedded script block and the next item in the scope
-
-        @returns a tuple containing the token with the variable name,
-        and the scope that represents the embedded script."""
-        token=next(tokiter)
-        if token.token_type != 'varname':
-            self.error('embed',token)
-        if token.token_value != 'bash':
-            self.error('embed',token,'unknown language "%s"'%(
-                    token.token_value,))
-        nametoken=next(tokiter)
-        if token.token_type != 'varname':
-            self.error('embed script name',token)
-        scope=EmbedBash(scopes)
-        token=next(tokiter)
-
-        while token.token_type==end_of_line_type: token=next(tokiter)
-        if token.token_type=='(':
-            self.parse_subscope(tokiter,[scope]+scopes,[')'],
-                                self.parse_between_arguments,
-                                allow_overwrite=False,
-                                allow_resolve=False,
-                                allow_null=True,
-                                only_scalars=True,
-                                scope_name='embed script parameters')
-            scope=scope.as_parameters(self.con(token,scopes))
-            token=next(tokiter)
-        while token.token_type==end_of_line_type: token=next(tokiter)
-
-        if token.token_type=='{':
-            self.parse_subscope(tokiter,[scope]+scopes,['}'],
-                                self.parse_between_assignments,
-                                allow_overwrite=True,
-                                allow_resolve=True,
-                                allow_null=False,
-                                allow_use=True,
-                                only_scalars=True,
-                                scope_name='embed script variables')
-            token=next(tokiter)
-        while token.token_type==end_of_line_type: token=next(tokiter)
-
-        if token.token_type in [ 'qstring', 'dqstring', 'bracestring' ]:
-            scope.settemplate(self.action_string([scope]+scopes,token))
-        else:
-            self.error('embed script contents',token)
-        if parse_between: 
-            parse_between(tokiter)
-        return (nametoken.token_value,scope)
-
-    def parse_set_list(self,tokiter,scopes):
-        """!Iterates over a list of set names, yielding each one.
-
-        Parses a comma-separated list of set names, yielding each set
-        name as a token.  Skips intervening commas or whitespace.
-
-        @param tokiter a peekable iterator that yields tokens
-        @param scopes a list of nested scopes (innermost first) surrounding the set list
-        @returns None (this is an iterator)"""
-        peek=tokiter.peek()
-        while peek.token_type=='varname':
-            yield peek.token_value
-            lvaltoken=peek
-            next(tokiter) # discard varname
-            peek=tokiter.peek()
-            while peek.token_type==end_of_line_type:
-                next(tokiter)
-                peek=tokiter.peek()
-            if peek.token_type=='==':
-                # this is an "if var==value" condition
-                next(tokiter) # consume ==
-                peek=tokiter.peek()
-                if peek.token_type!='varname':
-                    self.error('run setname @ ... var==',peek)
-                rvaltoken=next(tokiter)
-                lval=self.action_resolve(lvaltoken,scopes)
-                rval=self.action_resolve(rvaltoken,scopes)
-                yield lval == rval
-
-                peek=tokiter.peek()
-            if peek.token_type!=',':
-                return # reached end of list.
-            next(tokiter) # discard ","
-            peek=tokiter.peek()
-                
-    def parse_deplist(self,tokiter,scopes,task,ends):
-        """!Parses and iterates over a list of dependencies.
-
-        @param tokiter a peekable iterator that yields tokens
-        @param scopes a list of nested scopes (innermost first) surrounding the list of dependencies
-        @param task The task for which the dependencies are being declared
-        @param ends List of termination tokens for the dependency list"""
-        allscopes=[task]+scopes
-        peek=tokiter.peek()
-        while not peek.token_type in ends:
-            if peek.token_type=='varname':
-                varname=peek
-                next(tokiter)
-                peek=tokiter.peek()
-                if peek.token_type==end_of_line_type:
-                    continue # ignore blank lines
-                elif self.parse_between_arguments(tokiter,['{']):
-                    # varname is followed by a comma
-                    dep=self.action_resolve(varname,allscopes)
-                    self.action_dependency(task,scopes,dep)
-                    peek=tokiter.peek()
-                    continue
-                elif peek.token_type in ends:
-                    dep=self.action_resolve(varname,allscopes)
-                    self.action_dependency(task,scopes,dep)
-                    return
-                elif peek.token_type == '(':
-                    # This is a function call.
-                    next(tokiter)
-                    subscope=Scope(scopes)
-                    self.parse_subscope(tokiter,scopes,[')'],
-                                        self.parse_between_arguments,
-                                        allow_overwrite=False,
-                                        allow_resolve=False,
-                                        allow_null=True,
-                                        scope_name='dependency argument list')
-                    subscope=subscope.as_parameters(self.con(peek,scopes))
-                    peek=tokiter.peek()
-                    if self.parse_between_arguments(tokiter) \
-                            or peek.token_type in ends:
-                        dep=self.action_call(varname,peek,scopes,subscope)
-                        self.action_dependency(task,scopes,dep)
-                        peek=tokiter.peek()
-                        continue
-            self.error('dependency argument list',peek)
-    def parse_op_list(self,tokiter,scopes,subscope):
-        """!Parses and iterates over list of "target .operator. source" expressions.
-
-        @param tokiter a peekable iterator that yields tokens
-        @param scopes a list of nested scopes (innermost first) surrounding the list
-        @param subscope the Task for whom the operator list is being declared
-        @returns None; this is an iterator"""
-        token=next(tokiter)
-        strings=[ 'qstring', 'dqstring', 'bracestring' ]
-        if token.token_type != '{':
-            self.error('operation list',token)
-        while True:
-            # Get target of operation:
-            token=next(tokiter)
-            while token.token_type==end_of_line_type:
-                token=next(tokiter)
- 
-            if token.token_type=='varname' and token.token_value=='use':
-                peek=tokiter.peek()
-                if peek.token_type!='varname':
-                    self.error('operation list use statement',peek)
-                next(tokiter)
-                subscope.use_from(self.action_resolve(peek,scopes))
-                self.parse_between_assignments(tokiter)
-                peek=tokiter.peek()
-                if peek.token_type=='}':
-                    next(tokiter)
-                    return subscope
-                continue
-            elif token.token_type=='}':
-                return subscope
-            elif token.token_type not in strings:
-                self.error('operator target',token)
-            tgt=self.action_string(scopes,token)
-
-            # Get operator:
-            token=next(tokiter)
-            while token.token_type==end_of_line_type:
-                token=next(tokiter)
-            if token.token_type!='oper':
-                self.error('oper',token)
-            op=self.action_operator(scopes,token)
-
-            # Get source of operation (input or baseline file)
-            token=next(tokiter)
-            while token.token_type==end_of_line_type:
-                token=next(tokiter)
-            if token.token_type not in strings:
-                self.error('operator source (input or baseline)',token)
-            src=self.action_string(scopes,token)
-
-            # Add operator:
-            # FIXME: CONTEXT
-            subscope.add_binary_operator(
-                tgt,op,src,self.con(token,scopes))
-
-            self.parse_between_assignments(tokiter)
-            peek=tokiter.peek()
-            if peek.token_type=='}':
-                next(tokiter)
-                return subscope
-
-
-    def parse_hash_define(self,tokiter,scopes,subscope,parse_between=None,
-                          allow_deps=False,hash_type='hash'):
-        """!Parses a variable hash definition.
-
-        Parses a definition of the syntax "{ varname = rvalue, varname=rvalue, ...}"
-        where rvalue is any value that may be assigned to a variable (see parse_rvalue())
-
-        @param tokiter a peekable iterator that yields tokens
-        @param scopes a list of nested scopes (innermost first) surrounding the variable hash
-        @param parse_between a function called between "varname=rvalue" assignments, to skip over such things as commas
-        @param allow_deps If True, then parse_deplist() is called first, to parse a dependency list before the assignment list.
-        @param hash_type The type of hash, such as "task," for error messages.
-
-        @returns the resulting Scope"""
-        token=next(tokiter)
-        parameters=False
-
-        # if token.token_type=='(':
-        #     parameters=True
-        #     self.parse_subscope(tokiter,[subscope]+scopes,[')'],
-        #                         self.parse_between_arguments,
-        #                         allow_overwrite=False,
-        #                         allow_resolve=False,
-        #                         allow_null=True,
-        #                         scope_name=hash_type+' argument list')
-        #     subscope=subscope.as_parameters()
-        #     token=tokiter.next()
-
-        if allow_deps and token.token_type==':':
-            self.parse_deplist(
-                tokiter,[subscope]+scopes,subscope,['{'])
-            token=next(tokiter)
-
-        if token.token_type=='{':
-            next(tokiter)
-            self.parse_subscope(tokiter,[subscope]+scopes,['}'],
-                                self.parse_between_assignments,
-                                allow_overwrite=True,
-                                allow_resolve=True,
-                                allow_null=False,
-                                allow_use=True,
-                                scope_name=hash_type+' definition')
-        else:
-            self.error(
-                hash_type+' definition',token,
-                'missing {...} block in '+hash_type+' definition')
-
-        if parse_between:
-            parse_between(tokiter)
-
-        # yell('%-7s define Scope@%s with %sparameters\n'%(
-        #         hash_type.upper(),str(id(subscope)),
-        #         ' ' if parameters else 'no '))
-        return subscope
-
-    def parse_spawn_element(self,tokiter,scopes,spawn,ends):
-        """!Parses one element (block of MPI ranks) of a process
-        spawning block.  
-
-        Parses the individual, comma-separated elements of a spawn block:
-
-        @code
-           {"program_name", ranks=32, threads=1}
-        @endcode
-
-        Combines the result into a single scope and array.
-
-        @returns a tuple containing the array of arguments and the
-        resulting Scope."""
-        token=next(tokiter)
-        args=list()
-        opts=list()
-        saw_vars=False
-        strings=[ 'qstring', 'dqstring', 'bracestring' ]
-        while token.token_type not in ends:
-            if token.token_type in strings:
-                if saw_vars:
-                    self.error('spawn process',token,'var=value elements '
-                               'must come after all arguments')
-                args.append(token)
-                self.parse_between_arguments(tokiter,ends)
-                token=next(tokiter)
-                continue
-            elif token.token_type==end_of_line_type:
-                token=next(tokiter)
-                continue
-            elif token.token_type=='varname':
-                name=token.token_value
-                peek=tokiter.peek()
-                if peek.token_type != '=':
-                    self.error('spawn process',token)
-                next(tokiter)
-            else:
-                self.error('spawn process',token)
-            # we're at the value in varname=value
-            rvalue=self.parse_rvalue(
-                tokiter,scopes,['}',','],
-                only_scalars=True,use_references=True)
-            self.parse_between_arguments(tokiter,ends)
-            opts.append([name,rvalue])
-            token=next(tokiter)
-        scope=Scope(scopes)
-        allscopes=[scope]+scopes
-        for k,v in opts:
-            scope.setlocal(k,v)
-        if not args:
-            self.error('spawn process',token,'no command nor arguments')
-        for arg in args:
-            assert(isinstance(arg,Token))
-        argobjs=[ 
-            self.action_string(allscopes,arg) for arg in args]
-        return argobjs,scope
-
-    def parse_spawn_block(self,tokiter,scopes,name,spawn,ends,parse_between):
-        """!Parses a subprocess spawning subblock.
-
-        Parses a block of this form:
-        
-        @code
-           {"program_name", ranks=32, threads=1}
-        @endcode
-
-        The set braces are also parsed.  The parse_spawn_element()
-        function parses the individual, comma-separated, elements
-        within that block.  The results are sent to the spawn
-        argument.
-
-        @param tokiter a peekable iterator that yields tokens
-        @param scopes a list of nested scopes (innermost first)
-            surrounding the subprocess spawning block
-        @param name the name of the subprocess spawning block
-        @param ends the list of tokens that terminate the surrounding block
-        @param pars_between if specified, a function to call between the
-            individual subprocess spawn elements
-        @returns None
-        @see parse_spawn_element()"""
-        token=next(tokiter)
-        while token.token_type==end_of_line_type: 
-            token=next(tokiter)
-        while token.token_type not in ends:
-            if token.token_type!='{':
-                self.error('spawned process',token)
-            (args,opts)=self.parse_spawn_element(
-                    tokiter,scopes,spawn,['}'])
-            spawn.add_rank(args,opts)
-            if parse_between: parse_between(tokiter)
-            token=next(tokiter)
-
-    def parse_spawn(self,tokiter,scopes,name,spawn):
-        """!Parses a subprocess spawning block
-
-        Parses a block of this form:
-
-        @code
-           {
-             {"program_name", ranks=32, threads=1}
-             {"program_name", ranks=16, threads=1}
-             {"another_program", ranks=80, threads=1}
-           }
-        @endcode
-
-        The beginning and ending set braces are also consumed.  Uses
-        the parse_spawn_block() to parse the individual subblocks.
-        Constructs a scope containing the resuling information.
-
-        @param tokiter a peekable iterator that yields tokens
-        @param scopes a list of nested scopes (innermost first)
-        surrounding the subprocess spawn block
-
-        @param name the name of the subprocess spawn block
-        @param spawn the scope in which to store the subprocess
-        spawning block information.
-        @returns spawn"""
-        token=next(tokiter)
-        if token.token_type!='{':
-            self.error('spawn block',token)
-        while self.parse_spawn_block(tokiter,scopes,name,spawn,['}'],
-                                     self.parse_between_assignments):
-            continue
-        return spawn
-
-    def parse_autodetect(self,tokiter,scopes,taskname,task):
-        """!Parses an autodetect block
-
-        Parses a block of this form:
-
-        @code
-            autodetect plat (/ wcoss.phase1, theia /)
-        @endcode
-
-        Places the resulting information in the task argument.
-
-        @param tokiter a peekable iterator that yields tokens
-        @param scopes a list of nested scopes (innermost first)
-        surrounding the autodetect block
-        @param taskname the name of the autodetect block
-        @param task the scope in which to store the information."""
-        # Check for the (/ and skip it:
-        token=next(tokiter)
-        while token.token_type==end_of_line_type:
-            token=next(tokiter)
-        if token.token_type!='(/':
-            self.error('autodetect platform list',token)
-
-        while True:
-            peek=tokiter.peek()
-            while peek.token_type==end_of_line_type:
-                next(tokiter)
-                peek=tokiter.peek()
-            if peek.token_type=='/)':
-                next(tokiter)
-                return
-            rvalue=self.parse_rvalue(tokiter,scopes,['/)'],
-                                     self.parse_between_arguments,False)
-            task.add(rvalue)
-            peek=tokiter.peek()
-            self.parse_between_arguments(tokiter)
-            if peek.token_type=='/)':
-                next(tokiter)
-                return
-
-    def parse_load(self,tokiter,scope,seen_run):
-        """!Parses a "load" statement.
-        
-        Parses a statement of this form:
-
-        @code
-            load 'otherfile.input'
-        @endcode
-
-        This uses the tokiter's child() function to create a new
-        tokenizer that parses the specified file.  The parser then
-        parses the file using parse_subscope().  This acts as if the
-        file was inserted in the location of the "load" statement.
-
-        @param tokiter a peekable iterator that yields tokens.  It
-        must also have a child() function that can create a new
-        tokenizer for the loaded file
-        @param scope the scope in which the "load" statement resides
-        @param seen_run True if a "run" statement was seen.
-        @returns None
-        """
-        filetoken=next(tokiter)
-        if filetoken.token_type!='qstring':
-            self.error('load',token,"load statements can only include "
-                       "'single-quote strings'")
-        eoln=tokiter.peek()
-        if eoln.token_type not in [ end_of_line_type, end_of_text_type ]:
-            self.error('load',eoln,"a load statement must be followed "
-                       "by an end of line or the end of the script.")
-        newfile=filetoken.token_value
-        if not os.path.isabs(newfile):
-            newfile=os.path.join(os.path.dirname(filetoken.filename),newfile)
-        tokenizer=tokiter.child
-        with open(newfile,'rt') as fileobj:
-            new_tokenizer=tokenizer.for_file(fileobj,newfile)
-            new_tokiter=peekable(new_tokenizer)
-            self.parse_subscope(
-                    new_tokiter,[scope],[end_of_text_type],
-                    self.parse_between_assignments,
-                    allow_overwrite=False,
-                    allow_resolve=True,
-                    allow_run=True,
-                    allow_null=False,
-                    allow_use=False,
-                    allow_load=True,
-                    scope_name='global scope',
-                    seen_run=seen_run)
-        
-    def parse_subscope(
-        self,tokiter,scopes,ends,parse_between,
-        allow_overwrite=True,allow_resolve=True,
-        allow_run=False,allow_null=False,
-        allow_use=False,scope_name='subscope',
-        only_scalars=False,allow_load=False,
-        seen_run=False):
-
-        try:
-            return self.parse_subscope_impl(
-                tokiter,scopes,ends,parse_between,allow_overwrite,
-                allow_resolve,allow_run,allow_null,allow_use,scope_name,
-                only_scalars,allow_load,seen_run)
-        except Exception as e: # FIXME: change exception type
-            if tokiter.at_end():
-                sys.stderr.write('%s: %s\n'%(
-                        type(e).__name__,str(e)))
-            else:
-                peek=tokiter.peek()
-                filename=peek.filename
-                lineno=peek.lineno
-                sys.stderr.write('%s:%d: %s\n'%(
-                        filename,lineno,str(e)))
-            raise
-        
-    def parse_subscope_impl(
-        self,tokiter,scopes,ends,parse_between,
-        allow_overwrite=True,allow_resolve=True,
-        allow_run=False,allow_null=False,
-        allow_use=False,scope_name='subscope',
-        only_scalars=False,allow_load=False,
-        seen_run=False):
-        """!General subscope parser, used for parsing most scopes.
-
-        Parses a scope.  This includes the innermost (global) scope,
-        and anything within blocks like these:
-
-        @code
-            ( ... declarations and arguments ... )
-            { ... declarations ... }
-            (/ ... array elements ... /)
-        @endcode
-
-        The various arguments control what is allowed within the scope.
-
-        @param tokiter a peekable iterator that yields tokens
-
-        @param scopes a list of nested scopes (innermost first)
-          surrounding the scope to parse.  The scope being parsed is
-          the first element in this array.
-
-        @param ends tokens that indicate the end of the scope
-        @param parse_between tokens that separate pieces of the scope,
-          such as declarations, array elements, or arguments.
-        @param allow_overwrite are we allowed to replace values
-          that are already set in the scope?
-          
-        @param allow_resolve When a variable reference is encountered,
-        are we allowed to resolve it within the scope that is being
-        parsed?
-
-        @param allow_run Are "run" statements allowed in this scope?
-        @param allow_none If True, then lone variable names are allowed.
-          This is intended for use in argument lists.
-        @param allow_use Are "use" statements allowed in this scope?
-        @param scope_name The name of this scope, used for error reporting.
-        @param only_scalars If True, then only strings and numbers are 
-          allowed to be assigned to variables.  If False, anything
-          can be assigned.
-        @param allow_load Do we allow "load" statements in this scope?
-        @param seen_run Have we already seen a "run" statement within
-          this scope, before parse_subscope() was called?  If so,
-          it is an error to have declarations.
-
-        """
-        go=True # set to False once an "ends" is seen
-        seen_run=bool(seen_run) # Did we see an execution request yet?
-        token=None
-        strings=[ 'qstring', 'dqstring', 'bracestring' ]
-        def define(con,key,val):
-            if seen_run:
-                self.error(
-                    scope_name,token,
-                    reason='Definitions must come before execution '
-                    'requests.')
-            if not val.is_valid_rvalue(con):  # FIXME: con
-                self.error(scope_name,token,'not a valid rvalue: %s'%(
-                        elipses(repr(val)),))
-            # yell('%s:%s: define %s=%s\n'%(
-            #         token.filename,str(token.lineno),
-            #         str(key),repr(val)))
-            if allow_overwrite:
-                scopes[0].force_define(key,val)
-            else:
-                scopes[0].check_define(key,val)
-        if allow_resolve:
-            search_scopes=scopes
-        else:
-            search_scopes=scopes[1:]
-        while go:
-            token=next(tokiter)
-            if token.token_type=='varname':
-                peek=tokiter.peek()
-                if peek.token_type=='=':
-                    next(tokiter)
-                    define(self.con(token,scopes),token.token_value,
-                           self.parse_rvalue(tokiter,search_scopes,ends,
-                                             parse_between,
-                                             only_scalars=only_scalars,
-                                             use_references=True))
-                    parse_between(tokiter)
-                    continue
-                elif token.token_value=='load' and peek.token_type in strings:
-                    if not allow_load:
-                        self.error('subscope',token,'load statements are '
-                                   'only allowed in the global scope.')
-                    self.parse_load(tokiter,scopes[-1],seen_run)
-                    if parse_between:  parse_between(tokiter)
-                    continue
-                elif token.token_value=='use' and peek.token_type=='varname' \
-                        and allow_use:
-                    next(tokiter) # consume the peeked value
-                    self.action_use(scopes,peek,
-                                    only_scalars=only_scalars)
-                    if parse_between:  parse_between(tokiter)
-                    continue
-                elif allow_run and token.token_value=='run' \
-                        and peek.token_type=='varname':
-                    set_rvalue=self.parse_rvalue(tokiter,search_scopes,
-                                                 ends,parse_between)
-                    set_con=self.con(peek,scopes)
-                    runsets=list()
-                    peek=tokiter.peek()
-                    keep_by_set=True
-                    keep_by_comparison=None # Will be True/False if "==" is used
-                    if peek.token_type=='@':
-                        next(tokiter) # discard the @
-                        for setname in self.parse_set_list(
-                                tokiter,search_scopes):
-                            if setname is False or setname is True:
-                                keep_by_comparison=keep_by_comparison or setname
-                            elif setname not in runsets:
-                                assert(isinstance(setname,str))
-                                runsets.append(setname)
-                    keep = keep_by_set
-                    if keep_by_comparison is not None:
-                        keep = keep and keep_by_comparison
-                    if keep:
-                        if not runsets:
-                            runsets.append('**all**')
-                        seen_run=True
-                        self.action_run_by_name(set_rvalue,set_con)
-                        for setname in runsets:
-                            runobj=self.action_run_in_set(
-                                setname,set_rvalue,set_con)
-                    peek=tokiter.peek()
-                    if parse_between: parse_between(tokiter)
-                    continue
-                elif not only_scalars and token.token_value=='spawn' \
-                        and peek.token_type=='varname':
-                    taskname=peek.token_value
-                    next(tokiter)
-                    task=self.parse_spawn(tokiter,scopes,peek.token_value,
-                                          SpawnProcess(scopes))
-                    define(self.con(peek,scopes),taskname,task)
-                    if parse_between:  parse_between(tokiter)
-                    del taskname,task
-                    continue
-                elif not only_scalars and token.token_value in [
-                    'filters', 'criteria' ] and peek.token_type=='varname':
-                    taskname=peek.token_value
-                    next(tokiter)
-                    if token.token_value=='filters':
-                        task=Filters(scopes)
-                    elif token.token_value=='criteria':
-                        task=Criteria(scopes)
-                    task=self.parse_op_list(tokiter,scopes,task)
-                    define(self.con(peek,scopes),taskname,task)
-                    if parse_between:  parse_between(tokiter)
-                    del taskname,task
-                    continue
-                elif not only_scalars and token.token_value=='autodetect' \
-                        and peek.token_type=='varname':
-                    taskname=peek.token_value
-                    taskcon=self.con(peek,scopes)
-                    next(tokiter) # Skip name token
-                    task=AutoDetectPlatform()
-                    self.parse_autodetect(tokiter,scopes,taskname,task)
-                    task=self.action_autodetect(self.con(peek,scopes),
-                                                tokiter,scopes,taskname,task)
-                    define(taskcon,taskname,task)
-                    del taskname, task, taskcon
-                    continue
-                elif not only_scalars and token.token_value in [
-                        'build', 'task', 'test', 'compset', 'platform' ] \
-                        and peek.token_type=='varname':
-                    taskname=peek.token_value
-                    # yell('%-7s %-7s %s\n'%(
-                    #         'PARSE',token.token_value,taskname))
-                    next(tokiter) # consume the task name
-                    # yell('%-7s %-7s %s\n'%(
-                    #         'INIT',token.token_value,taskname))
-                    if token.token_value=='task':
-                        raise AssertionError('Should never make a Task')
-                        task=Task(scopes,taskname)
-                    elif token.token_value=='test' or token.token_value=='compset':
-                        task=Test(scopes,taskname,self.__run_mode)
-                        task._set_constants({'TEST_NAME':
-                                      String(scopes,taskname,False)})
-                    elif token.token_value=='build':
-                        task=Build(scopes,taskname)
-                        task._set_constants({'BUILD_NAME':
-                                      String(scopes,taskname,False)})
-                    elif token.token_value=='platform':
-                        task=Platform(scopes,taskname)
-                        task._set_constants({'PLATFORM_NAME':
-                                      String(scopes,taskname,False)})
-                    else:
-                        raise AssertionError(
-                            'Unrecognized subscope type "%s".'%(
-                                token.token_value,))
-                    task=self.parse_hash_define(
-                            tokiter,scopes,task,parse_between,
-                            allow_deps=token.token_value!='platform')
-                    # yell('%-7s %-7s %s\n'%('DEFINE',token.token_value,
-                    #                        taskname))
-                    define(self.con(peek,scopes),taskname,task)
-                    del taskname, task
-                    if parse_between:  parse_between(tokiter)
-                    continue
-                elif not only_scalars \
-                        and token.token_value=='hash' \
-                        and peek.token_type=='varname':
-                    hashname=peek.token_value
-                    next(tokiter) # consume the hash name
-                    define(self.con(peek,scopes),
-                           hashname,self.parse_hash_define(
-                            tokiter,scopes,Scope(scopes),parse_between))
-                    del hashname
-                    if parse_between:  parse_between(tokiter)
-                    continue
-                elif not only_scalars \
-                        and token.token_value=='embed' \
-                        and peek.token_type=='varname':
-                    (varname,script)=self.parse_embed_script(
-                        tokiter,scopes,parse_between)
-                    define(self.con(peek,scopes),varname,script)
-                    if parse_between:  parse_between(tokiter)
-                    continue
-                elif allow_null and (
-                    peek.token_value in ends or
-                    parse_between and parse_between(tokiter)):
-                    define(self.con(peek,scopes),
-                           token.token_value,null_value)
-                    if parse_between:  parse_between(tokiter)
-                    continue
-            elif token.token_type in ends:
-                return scopes[0]
-            elif token.token_type==end_of_line_type:
-                continue # ignore blank lines.
-            self.error(scope_name,token)
-    def parse_rvalue(self,tokiter,scopes,ends,parse_between=None,
-                     only_scalars=False,use_references=False):
-        """!Parses an rvalue, which is anything that can be stored in
-        to a storage location.
-
-        Parses rvalues.  Anything that can be stored in variables,
-        arguments, or elsewhere is an rvalue.  This includes
-        variables, strings, numbers, and named subscopes.
-
-        @param tokiter a peekable iterator that yields tokens
-        @param scopes a list of nested scopes (outermost first) surrounding the rvalue
-        @param ends the list of tokens that indicate the end of the
-          surrounding scope.
-        @param parse_between if the surrounding scope is a list of
-          expressions, arguments, or assignments, then this function is
-          called to skip values after the rvalue
-        @param only_scalars If True, only strings and numbers are allowed.
-        @returns the resulting rvalue"""
-
-        token=next(tokiter)
-        if token.token_type in [ 'qstring', 'dqstring', 'bracestring' ]:
-            ret=self.action_string(scopes,token)
-            if parse_between: parse_between(tokiter)
-            return ret
-        elif token.token_type == 'number':
-            ret=self.action_numeric(scopes,token)
-            if parse_between: parse_between(tokiter)
-            return ret
-        elif not only_scalars and token.token_type in '{':
-            subscope=Scope(scopes)
-            ret=self.parse_subscope(
-                tokiter,[subscope]+scopes,['}'],
-                self.parse_between_assignments,
-                allow_overwrite=True,
-                allow_resolve=True,
-                allow_run=False,
-                allow_null=False,
-                allow_use=True,
-                scope_name="hash")
-            if parse_between: parse_between(tokiter)
-            return ret
-        elif not only_scalars and token.token_type=='varname':
-            varname=token.token_value
-            peek=tokiter.peek()
-            if peek.token_type=='(':
-                # We are at the ( in varname(arguments...
-                next(tokiter) # consume (
-                subscope=Scope(scopes)
-                scopesplus=[subscope]+scopes
-                self.parse_subscope(tokiter,scopesplus,[')'],
-                                    self.parse_between_arguments,
-                                    allow_overwrite=False,
-                                    allow_resolve=False,
-                                    allow_null=True,
-                                    scope_name='argument list')
-                peek=tokiter.peek()
-                if peek.token_type in ends or \
-                        parse_between and parse_between(tokiter):
-                    # This is a function call varname(arg,arg,...)
-                    return self.action_call(varname,peek,scopes,subscope)
-            elif peek.token_type in ends :
-                if use_references:
-                    return self.action_reference(token,scopes)
-                else:
-                    return self.action_resolve(token,scopes)
-            elif parse_between and parse_between(tokiter):
-                if use_references:
-                    return self.action_reference(token,scopes)
-                else:
-                    return self.action_resolve(token,scopes)
-        self.error('rvalue',token)
-    def action_autodetect(self,con,tokiter,scopes,taskname,task):
-        """!Executes an autodetect block
-
-        Executes the "detect" function within each element of an
-        autodetect block, choosing the block whose detect function
-        returns True.  It is an error for more or less than one
-        platform to return True."""
-        matches=task.detect(con)
-        if self.requested_platform_name:
-            for match in matches:
-                name=match.resolve('PLATFORM_NAME').string_context(
-                    produtil.testing.parsetree.fileless_context(
-                        verbose=self.verbose))
-                if name == self.requested_platform_name:
-                    return match
-            raise PTParserError(
-                'The platform "%s" is not detected on this machine.'%(
-                    self.requested_platform_name,))
-        if len(matches)==0:
-            raise PTParserError(
-                'You are using an unknown platform.  Check your platforms.input file "autodetect" block.  Add support for this platform, or correct your platform detection logic.')
-        elif len(matches)>1:
-            raise PTPlatformError(
-                'This machine can submit to multiple platforms: '+(
-                    ' '.join([
-                      s.resolve('PLATFORM_NAME') \
-                       .string_context(
-                         produtil.testing.parsetree.fileless_context(
-                           verbose=self.verbose)) \
-                            for s in matches
-                ])))
-        return matches[0]
-    def action_dependency(self,task,scopes,dep):
-        """!Adds the specified dependency to the specified task.
-
-        @param task The task for whom the dependency is to be added.
-        @param dep The dependency
-        @param scopes The surrounding scopes (presently unused)"""
-        task.add_dependency(dep)
-    def action_call(self,varname,token,scopes,parameters):
-        """!Creates a scope that represents a function call.
-
-        @param varname The function to call.
-        @param parameters The arguments to the function.
-        @param token the context from which the function call is requested.
-        @param scopes a list of nested scopes (outermost first) surrounding the call
-
-        @returns a scope representing the given function call"""
-        # yell('%-7s %s in parameter scope %s\n'%(
-        #         'CALL',repr(varname),repr(parameters)))
-        callme=scopes[0].resolve(varname)
-        # yell('CALL APPLY PARAMETERS\n')
-        return callme.apply_parameters(parameters,self.con(token,scopes))
-    def action_use(self,scopes,key_token,only_scalars=False):
-        """!Performs the action of a "use" block within a subscope.
-
-        Adds variables to scope[0] from another scope.  The scope is
-        defined by key_token, a name that is resolved using scopes
-        surrounding scope[0]
-
-        @param scopes The relevant scopes: scope[0] is the scope that
-        is "using," while the other scopes are those surrounding
-        scope[0].
-
-        @param key_token The token containing the name of the scope
-        that is to be used.
-
-        @param only_scalars If True, then it is an error to "use" a 
-        scope that contains variables with non-scalar values.
-
-        @returns None"""
-        assert(isinstance(key_token,Token))
-        assert(isinstance(scopes,list))
-        assert(len(scopes)>=2)
-        assert(isinstance(scopes[0],Scope))
-        key=key_token.token_value
-        got=scopes[1].resolve(key)
-        found_non_scalars=scopes[0].use_from(got,only_scalars)
-        if only_scalars and found_non_scalars:
-            self.error('use',key_token,'found non-scalars when '
-                       'using %s'%(key,))
-        # for k,v in got.iterlocal():
-        #     if only_scalars and not isinstance(v,String):
-        #         self.error('use',key_token,'found non-scalars when '
-        #                    'using %s'%(key,))
-        #     scopes[0].setlocal(k,v)
-    def action_operator(self,scopes,token):
-        """!Creates an object that represents the operator ".oper." in
-        the expression "a .oper. b"
-
-        @param scopes a list of nested scopes (outermost first) surrounding the expression
-        @param token the token containing the name of the operator
-
-        @returns an object that represents the operator"""
-        assert(isinstance(token,Token))
-        if token.token_value=='.copy.':
-            return Copy(scopes)
-        elif token.token_value=='.copydir.' or token.token_value=='.copyfrom.':
-            return CopyDir(scopes)
-        elif token.token_value=='.bitcmp.':
-            return BitCmp(scopes)
-        elif token.token_value=='.nccmp_vars.':
-            return NccmpVars(scopes)
-        elif token.token_value=='.md5cmp.':
-            return Md5Cmp(scopes)
-        elif token.token_value=='.link.':
-            return Link(scopes)
-        elif token.token_value=='.atparse.':
-            return AtParse(scopes)
-        else:
-            self.error('operator name',token,'unknown operator '+
-                       token.token_value)
-    def action_numeric(self,scopes,token):
-        """!Returns a Numeric object for the given token.
-
-        @param scopes a list of nested scopes (outermost first) surrounding the number
-        @param token The token containing the number
-        @returns a Numeric object"""
-        value=float(token.token_value)
-        return Numeric(value)
-    def action_string(self,scopes,token):
-        """!Returns a String object for the given token.
-
-        @param scopes a list of nested scopes (outermost first) surrounding the string
-        @param token The token containing the string
-        @returns a String object"""
-        assert(isinstance(token,Token))
-        if token.token_type=='qstring':
-            s=String(scopes,token.token_value,False)
-        elif token.token_type=='dqstring':
-            s=String(scopes,dqstring2bracestring(token.token_value),True)
-        elif token.token_type=='bracestring':
-            s=String(scopes,token.token_value,True)
-        else:
-            raise ValueError('Invalid token for a string: '+repr(token))
-        # yell('%-7s %s = %s\n'%('STRING',repr(token.token_value),repr(s)))
-        return s
-    def action_reference(self,varname_token,scopes):
-        return Reference(varname_token.token_value,scopes)
-    def action_resolve(self,varname_token,scopes):
-        """!Resolves a variable reference within a scope.
-
-        @param varname_token The token containing the name of the variable reference.
-        @param scopes a list of nested scopes (outermost first) surrounding the reference
-        @returns the value of the referenced variable
-        @raise PTKeyError if no such variable exists"""
-        varname=varname_token.token_value
-        for scope in scopes:
-            try:
-                return scope.resolve(varname)
-            except PTKeyError as ke:
-                pass
-        raise PTKeyError(varname)
-    def action_null_param(self,varname,scope):
-        """!Defines a variable with no value in the given scope.
-
-        @param varname the name of the variable, a string
-        @param scope the scope in which to define the variable
-        @returns None"""
-        if '%' in varname:
-            raise ValueError('%s: cannot have "%" in a parameter name.'%(
-                    varname,))
-        scope.check_define(varname,null_value)
-    def action_assign_var(self,toscope,tovar,fromvar,fromscopes,
-                          allow_overwrite):
-        """!Assigns a value to a variable within a scope, from another
-        variable in another scope.
-
-        @param toscope The scope in which a variable is being defined.
-        @param tovar The target variable name
-        @param fromvar The variable reference to the source variable
-        @param fromscopes The scopes, innermost first, in which to resolve
-          the fromvar variable reference
-        @param allow_overwrite If True, redefining tovar within toscope is allowed."""
-        if fromscopes:
-            value=fromscopes[0].resolve(fromvar)
-        else: # Global scope assignment
-            value=toscope.resolve(fromvar)
-        self.action_assign(toscope,tovar,value,allow_overwrite)
-    def action_assign(self,scope,varname,value,allow_overwrite):
-        """!Assigns a value to a variable within a scope
-
-        @param scope The scope in which to assign.
-        @param varname The name of the variable within the scope, a string.
-        @param value The value of the variable, a BaseObject
-        @param allow_overwrite If True, replacing an existing
-          variable's value is allowed.
-        @return None"""
-        assert(isinstance(scope,Scope))
-        assert(isinstance(varname,str))
-        assert(isinstance(value,BaseObject))
-        if '%' in varname:
-            raise ValueError('Cannot assign to %s; subscope definitions must be of syntax "var1 = { var2= { ...."'%(
-                    varname,))
-        # yell('%-7s %s = %s IN %s\n'%(
-        #     'ASSIGN', varname, repr(value),repr(scope) ))
-        if allow_overwrite:
-            scope.force_define(varname,value)
-        else:
-            scope.check_define(varname,value)
-    def action_run_in_set(self,setname,obj,con):
-        """!Requests that a specified object be available for running,
-        within a specific runset.  This is used to implement the part
-        list of runsets in the "run" statement.
-
-        @param setname The name of the set in which to run.
-        @param obj The object to run.
-        @param con The produtil.testing.parsetree.Context from which
-        the run statement is made."""
-        # yell('%-7s %s\n'%(
-        #     'RUN', repr(obj)))
-        return self.add_run(setname,obj,con)
-    def action_run_by_name(self,obj,con):
-        """!Requests that a specified object be available for running,
-        without putting it in any runset.  This is used to implement
-        the part of the "run" statement before set lists.
-        
-        @param obj The object to run.
-        @param con The produtil.testing.parsetree.Context from which
-        the run statement is made."""
-        return self.add_run(None,obj,con)
-    def error(self,mode,token,reason=None):
-        """!Convenience function for error messages.
-
-        Raises an exception explaining that an input file contains an
-        error.  This is used for most syntax or semantic errors.
-
-        @param mode The run mode, which can be anything that can be
-         cast to a string via str()
-        @param token The token at which the error occurred, or None
-         if the end of the file was reached.
-        @param reason
-        @returns Never.  Always raises an exception."""
-        if token is None:
-            raise PTParserError('Unexpected end of file.')
-        elif reason:
-            raise PTParserError('%s:%s: %s (%s token with value %s)'%(
-                    token.filename,token.lineno,str(reason),
-                    repr(token.token_type),
-                    repr(elipses(str(token.token_value)))))
-        else:
-            raise PTParserError(
-                '%s:%s: unexpected %s in %s (token value %s)'%(
-                    token.filename, token.lineno, repr(token.token_type),
-                    str(mode), repr(elipses(str(token.token_value)))))
diff --git a/produtil/testing/parsetree.py b/produtil/testing/parsetree.py
deleted file mode 100644
index 4c5a8dad4f..0000000000
--- a/produtil/testing/parsetree.py
+++ /dev/null
@@ -1,2781 +0,0 @@
-##@namespace produtil.testing.parsetree
-# Parse tree classes for the produtil.testing suite.
-#
-# The produtil.testing.parse.Parser class uses this module to
-# construct a parse tree of the test suite.  The tree consists of
-# subclasses of BaseObject, connected to one another by scopes or
-# operators.  The Context class provides filename, line number, run
-# mode, call stack, and other information which the BaseObject
-# subclasses use for evaluation to literals.
-
-import sys, re, io, collections, os, datetime, logging, math
-import produtil.run, produtil.log, produtil.setup
-
-# This module really does use everything public from utilities and
-# tokenize, hence the "import *"
-from produtil.testing.utilities import *
-from produtil.testing.tokenize import *
-
-__all__=[ 'Context', 'BaseObject', 'null_value', 'TypelessObject', 'Scope',
-          'make_params', 'make_scope', 'call_scope', 'Builtin', 'Copy', 
-          'CopyDir', 'Link', 'AtParse', 'BitCmp', 'Criteria', 'Filters',
-          'Rank', 'SpawnProcess', 'EmbedBash', 'Task', 'Build', 'Platform',
-          'Test', 'AutoDetectPlatform', 'Numeric', 'String', 'Environ',
-          'Md5Cmp', 'Reference', 'NccmpVars']
-
-class Context(object):
-    """!Represents the context from which a BaseObject is accessed.  
-
-    The Context is used during any evaluation of a BaseObject to a
-    logical, numeric, block of bash code, or other type.  A Context consists
-    of the relevant token (for filename and line number), the run mode
-    (baseline or execution), the call stack, and logging information.
-    The BaseObject subclasses use that information for variable
-    resolution or error reporting."""
-    def __init__(self,scopes,token,run_mode,logger,verbose=True):
-        """!Constructor for Context
-
-        @param scopes The call stack for the context, innermost scope first.
-        @param token The token that represents the Context; this is for
-           error reporting.
-        @param run_mode produtil.testing.utilities.BASELINE or
-          produtil.testing.utilities.EXECUTION
-        @param logger a logging.Logger object to log messages
-        @param verbose send extra logging to assist debugging or tracking progress. """
-        super(Context,self).__init__()
-        self.run_mode=run_mode
-        self.token=token
-        self.scopes=scopes
-        if logger is None:
-            logger=module_logger
-        self.logger=logger
-        self.verbose=bool(verbose)
-    @property
-    def filename(self):
-        """!The filename from self.token"""
-        return self.token.filename
-    @property
-    def lineno(self):
-        """!The line number from self.token"""
-        return self.token.lineno
-
-    def __str__(self):
-        return "%s:%s"%(self.token.filename,str(self.token.lineno))
-
-    def mpirunner(self,spawnProcess):
-        """!Returns an object that can run the MPI program described
-        in the spawnProcess.  The base class does not implement this;
-        subclasses must override this function.
-
-        @param spawnProcess a SpawnProcess object to run."""
-        raise NotImplementedError('Base Context class does not know how '
-                                  'to run MPI processes.')
-    def info(self,message):
-        """!Logs a message at logging.INFO level to self.logger
-        @param message a string message to log"""
-        message="%s:%s: %s"%(
-                str(self.token.filename),
-                repr(self.token.lineno),
-                message)
-        self.logger.info(message)
-        return message
-    def warning(self,message):
-        """!Logs a message at logging.WARNING level to self.logger
-        @param message a string message to log"""
-        message="%s:%s: %s"%(
-                str(self.token.filename),
-                repr(self.token.lineno),
-                message)
-        self.logger.warning(message)
-        return message
-    def error(self,message):
-        """!Logs a message at logging.ERROR level to self.logger
-        @param message a string message to log"""
-        message="%s:%s: %s"%(
-                str(self.token.filename),
-                repr(self.token.lineno),
-                message)
-        self.logger.error(message)
-        return message
-
-def fileless_context(scopes=None,filename=None,lineno=None,
-                     run_mode=None,logger=None,verbose=True):
-    """!Generates a Context object that is not connected to a
-    Tokenizer.  This is to be used when resolving and evaluating
-    objects from outside the workflow description.
-
-    @param scopes Optional: the call stack, innermost scope first
-    @param filename Optional: a filename representative of the Context
-    @param lineno Optional: a line number representative of the Context
-    @param run_mode """
-    if scopes is None: scopes=[]
-    if filename is None: filename=unknown_file
-    if lineno is None: lineno=-1
-    if logger is None: logger=module_logger
-    if run_mode is None: run_mode=EXECUTION
-    return Context(
-        scopes,Token(end_of_line_type,end_of_line_type,filename,lineno),
-        run_mode,logger,verbose)
-
-class BaseObject(object):
-    """!Base class of the parsetree hierarchy.  
-
-    This class implements default behaviors representative of any
-    parsetree node.  The properties and functions should be overridden
-    by subclasses, as appropriate."""
-
-    ##@var defscopes
-    # A list of Scope objects that represent the call stack at
-    # which this object is being called, or the stack to the context
-    # at which the object is being defined.  Innermost Scope is first.
-
-    ##@var is_scope
-    # If True, this object can be treated as a Scope
-
-    ##@var is_filters
-    # If True, this object can be treated as a set of filters
-
-    ##@var is_criteria
-    # If True, this object can be treated as a list of output validation criteria
-
-    ##@var is_scalar
-    # If True, this is a scalar, such as a number or string.
-
-    ##@var can_be_used
-    # If True, this object is a valid target for a "use" statement
-
-    ##@var is_test
-    # If True, this object can be used as a Test.  This means it can
-    # be, and have, dependencies.  It must also have a COM variable.
-
-    def __init__(self,defscopes,set_flags=True):
-        """!Constructor for BaseObject
-        @param defscopes The list of nested scopes to the point at
-        which this object is defined.  The innermost scope is listed
-        first."""
-        for s in defscopes:
-            if not isinstance(s,Scope):
-                raise TypeError('In BaseObject(), the defscopes must be a list '
-                                'of Scope objects.  One of them is a %s %s'%(
-                                    type(s).__name__,repr(s)))
-        self.defscopes=defscopes
-        if set_flags:
-            self.is_scope=False
-            self.is_filters=False
-            self.is_criteria=False
-            self.is_scalar=False
-            self.can_be_used=False
-            self.is_test=False
-    def bash_context(self,con):
-        """!Expresses this object in bash code.
-
-        This function is intended to express this object as bash code.
-        The default implementation raises an exception.
-
-        @param con the Context in which this object is being evaluated
-        @returns a string containing this object expressed in bash code"""
-        raise PTParserError("Cannot express null_value in a bash string.")
-    def oldcmp(self,other):
-        iself=id(self)
-        iother=id(other)
-        if iself<iother: return -1
-        if iself>iother: return 1
-        return 0
-    def is_valid_rvalue(self,con): 
-        """!Can this value be assigned to a variable?
-        @returns True if this BaseObject represents a value that can be
-        assigned to a variable, False otherwise
-        @param con the Context in which this object is being evaluated"""
-        return True
-    def string_context(self,con): 
-        """!Expresses this object as a printable string
-
-        Expresses the object as a human-readable string in the provide
-        context.  The default implementation returns "null"
-
-        @returns A string representation of this object
-        @param con the Context in which this object is being evaluated"""
-        return "null"
-    def logical_context(self,con): 
-        """!Expresses this object as a printable string
-
-        Expresses the object as a boolean True/False value.  The
-        default implementation returns False
-
-        @returns A boolean representation of this object
-        @param con the Context in which this object is being evaluated"""
-        return False
-    def numeric_context(self,con): 
-        """!Expresses this object as a float
-
-        Expresses the object as a Python float.  The default implementation
-        returns 0.0
-
-        @returns A float representation of this object
-        @param con the Context in which this object is being evaluated"""
-        return 0.0
-    def _apply_rescope(self,scopemap=None,prepend=None):
-        """!Replaces Scope objects in this object's defscopes variable.
-
-        This function is the internal implementation of the "use"
-        blocks and function calls when parsing or evaluating.
-        Subclasses with a rescope() or similar function use
-        _apply_rescope() to implement such functions.
-
-        @param scopemap A mapping from old Scope to new Scope
-        @param prepend A list of Scope objects to prepend to defscopes
-        @protected"""
-        if not prepend: prepend=[]
-        if not scopemap: scopemap={}
-        self.defscopes=prepend+[ scopemap[s] if s in scopemap else s
-                                 for s in self.defscopes ]
-        for s in self.defscopes:
-            if not isinstance(s,Scope):
-                raise TypeError(
-                    'In make_scope, the defscopes must be a list '
-                    'of Scope objects.  One of them is a %s %s'%(
-                        type(s).__name__,repr(s)))
-
-    def rescope(self,scopemap=None,prepend=None):
-        """!Modifies this object's scopes, and that of any subobjects.
-
-        Subclasses that can be expressed as non-constant values must
-        implement this function for rescoping.  This function changes
-        the stack of defining scopes, defscopes, based on arguments
-
-        @param scopemap a mapping from old Scope to new Scope during
-        the replacement
-
-        @param prepend a list of Scope objects to prepend.  These
-        become the innermost scopes.  The scopemap is NOT applied to
-        the prepend list.
-        @returns self"""
-        raise NotImplementedError('Subclass %s did not implement rescope()'%(type(self).__name__,))
-    def run(self,con): 
-        """!Instructs this object to execute.
-
-        Subclasses that can be executed, such as scripts, must
-        implement this function to execute themselves.  The default
-        implementation logs the string representation of this object
-        at logging.INFO level.
-
-        @param con the Context in which this object is being
-        evaluated.  This Context is also used to get the logger for
-        logging in the default implementation of this function.
-        @returns None"""
-        con.logger.info(self.string_context(con))
-    def iterdeps(self):
-        """!Iterates over all runnable objects that are dependencies
-        of this object.
-
-        Objects that can be executed, such as Test or Build, have a
-        list of dependencies.  Those dependencies are instances of
-        BaseObject subclasses, such as other Test or Build objects."""
-        return
-        yield 'a' # Syntactic trick to ensure this is an iterator.
-    def __repr__(self):
-        return '<BaseObject@%s>'%(id(self),)
-    def __str__(self):
-        return '<BaseObject@%s>'%(id(self),)
-
-##@var null_value
-# A special constant that indicates a variable without a value. 
-# @warning Terrible things will happen if you overwrite this.
-null_value=BaseObject([])
-
-########################################################################
-
-class TypelessObject(BaseObject):
-    """!Represents an object that cannot be evauated in any context.
-    This is a convenience class intended to be used by subclasses to
-    disable all but certain contexts."""
-    def bash_context(self,con):
-        """!Raises TypeError to indicate the object cannot be evaluated.
-        @param con the Context in which this object is being evaluated"""
-        raise TypeError('Cannot evaluate %s in a bash context.'%(
-                type(self).__name__,))
-    def string_context(self,con):
-        """!Raises TypeError to indicate the object cannot be evaluated.
-        @param con the Context in which this object is being evaluated"""
-        raise TypeError('Cannot evaluate %s in a string context.'%(
-                type(self).__name__,))
-    def logical_context(self,con):
-        """!Raises TypeError to indicate the object cannot be evaluated.
-        @param con the Context in which this object is being evaluated"""
-        raise TypeError('Cannot evaluate %s in a logical context.'%(
-                type(self).__name__,))
-    def numeric_context(self,con):
-        """!Raises TypeError to indicate the object cannot be evaluated.
-        @param con the Context in which this object is being evaluated"""
-        raise TypeError('Cannot evaluate %s in a numeric context.'%(
-                type(self).__name__,))
-    def run(self,con):
-        """!Raises TypeError to indicate the object cannot be executed.
-        @param con the Context in which this object is being evaluated"""
-        raise TypeError('Cannot run objects of type %s.'%(
-                type(self).__name__,))
-
-########################################################################
-
-class Reference(BaseObject):
-    """!Represents a reference to another variable"""
-    def __init__(self,path,defscopes=None):
-        if defscopes is None:
-            defscopes=list()
-        super(Reference,self).__init__(defscopes,set_flags=False)
-        self.__path=path
-        
-    @property
-    def is_scope(self):
-        return self.dereference().is_scope
-    @property
-    def is_filters(self):
-        return self.dereference().is_filters
-    @property
-    def is_criteria(self):
-        return self.dereference().is_criteria
-    @property
-    def is_scalar(self):
-        return self.dereference().is_scalar
-    @property
-    def can_be_used(self):
-        return self.dereference().can_be_used
-    @property
-    def is_test(self):
-        return self.dereference().is_test
-    def override_local(self,defscopes,key,val):
-        return self.dereference().override_local(defscopes,key,val)
-    def no_nulls(self):
-        return self.dereference().no_nulls()
-    def get_type(self,key):
-        return self.dereference().get_type(key)
-    def as_parameters(self,con):
-        return self.dereference().as_parameters(con)
-    def has_parameters(self):
-        return self.dereference().has_parameters()
-    def has_constants(self):
-        return self.dereference().has_constants()
-    def use_from(self,used_scope,only_scalars=False):
-        return self.dereference().use_from(used_scopes,only_scalars)
-    def apply_parameters(self,scope,con):
-        return self.dereference().apply_parameters(scope,con)
-    def subscope(self,key):
-        return self.dereference().subscope(key)
-    def getlocal(self,key):
-        return self.dereference().getlocal(key)
-    def setlocal(self,key):
-        return self.dereference().setlocal(key)
-    def haslocal(self,key):
-        return self.dereference().haslocal(key)
-    def iterlocal(self):
-        for i in self.dereference().iterlocal():
-            yield i
-    def force_define(self,key,value,skip_constants=False):
-        return self.dereference().force_define(key,value,skip_constants)
-    def check_define(self,key,value):
-        return self.check_define(key,value)
-    def expand_string(self,key,value):
-        return self.dereference().expand_string(string,con,scopes)
-    def new_empty(self):
-        return Reference(self.__path,self.defscopes)
-    @property
-    def path(self):
-        return self.__path
-    def rescope(self,scopemap=None,prepend=None):
-        r=self.new_empty()
-        r._apply_rescope(scopemap,prepend)
-        return r
-    def resolve(self,key,scopes=None):
-        return self.dereference().resolve(key,scopes=scopes)
-    def dereference(self):
-        return self.defscopes[0].resolve(self.__path,self.defscopes[1:])
-    def bash_context(self,con):
-        return self.dereference().bash_context(con)
-    def string_context(self,con):
-        return self.dereference().string_context(con)
-    def logical_context(self,con):
-        return self.dereference().logical_context(con)
-    def numeric_context(self,con):
-        return self.dereference().numeric_context(con)
-    def __str__(self):
-        return 'Reference(path=%s)'%(str(self.__path),)
-    def __repr__(self):
-        return 'Reference(path=%s)'%(repr(self.__path),)
-    def __bool__(self):
-        return bool(self.__path)
-
-########################################################################
-
-class Scope(BaseObject):
-    """!Represents a scope; the region of which a name binding can be
-    evaluated. This includes hashes, tests, argument lists, and
-    anything else with variable names or named arguments."""
-    def __init__(self,defscopes=None):
-        if defscopes is None:
-            defscopes=list()
-        super(Scope,self).__init__(defscopes)
-        self.__const=dict()
-        self.__vars=dict()
-        self.__parameters=dict()
-        self.is_scope=True
-        self.can_be_used=True
-        self.__overrides=collections.defaultdict(list)
-
-    def __eq__(self,other):
-        """!Scopes are equal iff they are the same object.
-        @param the other Scope against which to compare"""
-        return self is other
-
-    def override_local(self,defscopes,key,val):
-        """!Overrides a variable already defined in this scope or its subscopes
-
-        @param defscopes a list of Scope objects that represent scopes
-        outside of this one for the purpose of variable overrides
-        @param key the path to the variable to override.  This may
-        include "%" but it is always relative to this scope.
-        @param val the valuate to assign.  This is re-expressed as a String"""
-        names=splitkey(key)
-        the_string=String(self.defscopes+[self],val,False)
-        #print 'overrides %s%%%s = %s'%(repr(names[0]),repr(names[1:]),repr(the_string))
-
-        self.__overrides[names[0]].append([ names[1:],the_string])
-
-    def validate_parameter(self,name): 
-        """!Raises an exception if the given name is not an acceptable
-        keyword for constants or parameters.  The default
-        implementation does nothing."""
-        pass
-
-    def new_empty(self): 
-        """!Returns a new, empty scope that is within the same parent
-        scope of this Scope (has the same defscopes)."""
-        return Scope(self.defscopes)
-
-    def bash_context(self,con):
-        """!Raises an exception to indicate that a Scope cannot be
-        expressed in bash code.
-        @param con the Context in which this object is being evaluated"""
-        raise PTParserError("Cannot express a hash in a bash string.")
-
-    def string_context(self,con): 
-        """!Evaluates the _as_string variable in this scope, in a
-        string context, if it is defined.  Otherwise, returns the
-        Python id of this Scope (id(self)) as a string.
-        @param con the Context in which this object is being evaluated"""
-        if self.haslocal('_as_string'):
-            value=self.getlocal('_as_string')
-            return value.string_context(con)
-        else:
-            return str(id(self))
-
-    def no_nulls(self):
-        """!Are there any local variables defined to have null values?
-        @returns False if any local variable has a null_value, or True
-        if no variables have null values """
-        for k,v in self.iterlocal():
-            if v is null_value:
-                return False
-        return True
-
-    def _set_parameters(self,update):
-        """!Internal implementation function that updates the list of
-        parameters (arguments to function call)
-        @param update a dict containing the new variable names and values"""
-        self.__parameters.update(update)
-        for p in self.__parameters.keys():
-            self.validate_parameter(p)
-
-    def _set_constants(self,update):
-        """!Internal implementation function that updates the list of
-        constants in this scope
-        @param update a dict containing the new variable names and values"""
-        self.__const.update(update)
-        for p in self.__const.keys():
-            self.validate_parameter(p)
-
-    def numeric_context(self,con):
-        """!Evaluates this scope in a numeric context
-
-        @returns the number of variables, parameters (function call
-        arguments) and constants defined in this Scope
-        @param con the Context in which this object is being evaluated (unused)"""
-        return len(self.__vars) + len(self.__parameters) + len(self.__const)
-
-    def logical_context(self,con): 
-        """!Evaluates this scope in a logical context
-        @returns True if any variables, parameters (function call
-        arguments) or constants are defined in this Scope.  Returns False otherwise.
-        @param con the Context in which this object is being evaluated (unused)"""
-        return bool(self.__vars) or bool(self.__parameters) or bool(self.__const)
-
-    def get_type(self,key):
-        """!Returns the type of variable that the key represents
-
-        Searches for a variable name in the parameter (function call
-        argument) list, the constant variable list, and the local
-        variable list, in that order.  Returns the type of variable
-        based on the first of those three lists that contains the
-        variable name.  Note that this only searches for variable
-        names; it will not work for variable paths (names containing "%")
-
-        @param key the variable to search for; must not contain "%"
-        @returns the variable type: "parameter" "constant" "var" or None"""
-        if key in self.__parameters:
-            return 'parameter'
-        elif key in self.__const:
-            return 'constant'
-        elif key in self.__vars:
-            return 'var'
-        else:
-            return None
-
-    def as_parameters(self,con):
-        """!Changes all variables to parameters.
-        @param con the Context in which this object is being evaluated"""
-        self.__parameters.update(self.__vars)
-        self.__vars=dict()
-        for p in self.__parameters.keys():
-            self.validate_parameter(p)
-        return self
-
-    def _apply_rescope(self,scopemap=None,prepend=None):
-        """!Internal implementation of rescope()
-
-        Modifies the the context of this Scope and everything below
-        it.  This is done by replacing Scope objects in defscopes.
-        Asks all variables and subscopes to do the same, recursively.
-
-        @protected
-        @param scopemap a mapping from old Scope to new Scope;
-        elements of defscopes are replaced based on this mapping
-        @param prepend a list of Scope objects to prepend to
-        defscopes.  The scopemap is not applied to the prepend
-        list.
-        @returns None"""
-        super(Scope,self)._apply_rescope(scopemap,prepend)
-        for d in [ self.__parameters, self.__vars, self.__const]:
-            for k,v in d.items():
-                v._apply_rescope(scopemap,prepend)
-
-    def rescope(self,scopemap=None,prepend=None):
-        """!Changes the context of this Scope.
-
-        Modifies the the context of this Scope and everything below
-        it, including parameters, variables and constants.  This is
-        done by replacing Scope objects in defscopes.  Asks all
-        variables and subscopes to do the same, recursively.  This
-        recursion is done by calling the _apply_rescope() function in
-        each object.
-
-        @param scopemap a mapping from old Scope to new Scope;
-        elements of defscopes are replaced based on this mapping
-        @param prepend a list of Scope objects to prepend to
-        defscopes.  The scopemap is not applied to the prepend
-        list.
-        @returns self"""
-        scope=self.new_empty()
-        scope._apply_rescope(scopemap,prepend)
-        for k,v in self.__parameters.items():
-            scope.__parameters[k]=v.rescope(scopemap,prepend)
-        for k,v in self.__vars.items():
-            scope.__vars[k]=v.rescope(scopemap,prepend)
-        for k,v in self.__const.items():
-            scope.__const[k]=v.rescope(scopemap,prepend)
-        return scope
-
-    def has_parameters(self):
-        """!Does this Scope contain parameters (function call arguments)?
-        @return True if any parameters (function call arguments) are present, False otherwise."""
-        return bool(self.__parameters)
-
-    def has_constants(self):
-        """!Are there any constants defined in this scope?
-        @return True if this scope contains constants, False otherwise"""
-        return bool(self.__const)
-
-    def use_from(self,used_scope,only_scalars=False):
-        """!Implements a "use" statement; copies definitions from another Scope
-
-        Copies parameters, constants, and variables from another scope
-        into this one.  Copies are modified to have this scope in
-        their definition or calling stack via the rescope() function.
-
-        @param used_scope The scope whose data is being copied.
-        @param only_scalars If True, then only the objects with
-        is_scalar=True are copied.
-        @returns True if all variables seen were scalar, False if any
-        non-scalar variables were seen.  This includes variables that
-        were found, but not "used," due to only_scalars=True"""
-        if used_scope.has_parameters():
-            raise PTParserError('A function cannot have a "use" statement.')
-        if not used_scope.is_scope:
-            raise PTParserError('Target of "use" statement is not a scope.')
-        if not used_scope.can_be_used:
-            raise PTParserError('Target of "use" statement cannot be used.')
-        prepend_me=[ self ]
-        found_non_scalars=False
-        for k,v in used_scope.iterlocal():
-            if only_scalars and v.is_scope:
-                found_non_scalars=True
-            if k not in self.__const:
-                my_v=v.rescope({used_scope:self})
-                self.force_define(k,my_v)
-
-        if used_scope.haslocal('RUNDIR'):
-            mycon=fileless_context([self])
-            usedcon=fileless_context([used_scope])
-                
-        return found_non_scalars
-    def apply_parameters(self,scope,con):
-        """!Implements a function call using this Scope as the parameter list.
-
-        Creates a new Scope where all parameters in this scope are
-        converted to local variables and possibly overridden.  Scope
-        self's parameters are used for the default argument values.
-        The "scope" argument to apply_parameters() contains values to
-        override those.  Hence, self is the function definition and
-        scope is the values set in the function call.  
-
-        A third Scope is created, containing the result of applying
-        the function call and default values.  That third Scope has no
-        parameters; all parameters have been converted to local
-        values.  The returned Scope has the same defscopes as self.
-        That means any unresolved variables within the function will
-        be resolved in the defining context, NOT the calling context.
-
-        @param scope The arguments provided to the function call.
-        @param con the Context at which this function is being called.
-           The defining location is in defscopes.
-        @returns a Scope representing the function call."""
-        assert(not scope.__parameters)
-        assert(self.__parameters)
-        if not self.__parameters:
-            return self
-        s=self.new_empty()
-        s._apply_rescope({self:s,scope:s})
-        caller=con.scopes[0]
-        #print('APPLY PARAMETERS from %s to %s type %s\n'%(
-        #        repr(scope),repr(self),type(s).__name__))
-        for k,v in scope.iterlocal():
-            if not k in self.__parameters:
-                raise PTKeyError('%s: not a valid argument to this function.'%(
-                        str(k),))
-        for k,v in self.__parameters.items():
-            if scope.haslocal(k):
-                s.__vars[k]=scope.getlocal(k).rescope({self:s,scope:s})
-            elif v is not null_value:
-                s.__vars[k]=v.rescope({self:s,scope:s})
-            else:
-                raise PTParserError('%s: no argument sent for this parameter'%(
-                        k,))
-        for k,v in self.__vars.items():
-            if k not in s.__vars:
-                s.__vars[k]=v.rescope({self:s,scope:s})
-        for k,v in self.__const.items():
-            if k not in s.__const:
-                s.__const[k]=v.rescope({self:s,scope:s})
-        #print('APPLY RESULT IS %s %s\n'%(
-        #        type(s).__name__,repr(s)))
-        return s
-
-    def __str__(self):
-        return '{' + ','.join( [
-                "%s=%s"%(str(s),repr(k)) for s,k in self.iterlocal()
-                ] ) + '}'
-
-    def __repr__(self):
-        return '{' + ','.join( [
-                "%s=%s"%(str(s),repr(k)) for s,k in self.iterlocal()
-                ] ) + '}'
-
-    def subscope(self,key):
-        """!Returns a Scope within this Scope, with the given name.
-        
-        @param key a valid identifier within this scope
-        @returns a Scope with the given name, within this Scope
-        @raise ValueError if the key contains a "%"
-        @raise TypeError if the key refers to something in this Scope
-          that is not a Scope.  This is detected through the is_scope 
-          attribute or property."""
-        if "%" in key:
-            raise ValueError("Key \"%s\" is not a valid identifier"%(key,))
-        if key in self.__parameters:
-            value=self.__parameters[key]
-        elif key in self.__const:
-            value=self.__const[key]
-        else:
-            value=self.__vars[key]
-        try:
-            if value.is_scope:
-                return value
-        except AttributeError as ae:
-            pass # value does not define is_scope
-        raise TypeError("Key \"%s\" refers to something that is not a Scope."
-                        %(key,))
-
-    def getlocal(self,key):
-        """!Return the value of a key local to this scope without
-        searching other scopes.  Will raise ValueError if the key
-        contains a "%" 
-
-        @param key a valid identifier within this scope
-        @returns The value of the key from this scope.
-        @raise ValueError if the key is syntactically not a valid identifier
-           such as one that contains a "%"
-        @raise KeyError if the key is a valid identifier but is not
-        within this scope."""
-        if "%" in key:
-            raise ValueError("Key \"%s\" is not a valid identifier"%(key,))
-        if key in self.__parameters:
-            return self.__parameters[key]
-        elif key in self.__const:
-            return self.__const[key]
-        elif key in self.__vars:
-            return self.__vars[key]
-        raise PTKeyError(key)
-
-    def setlocal(self,key,value):
-        """!Sets the value of a key within this scope.
-
-        @param key a valid identifier to set within this scope
-        @param valuel the value of the identifier
-        @raise ValueError if the key is not a valid identifier, such as
-          one that contains a "%" """
-        if not isinstance(value,BaseObject):
-            raise TypeError('The value argument to setlocal must be a '
-                            'subclass of BaseObject, not a %s %s'%(
-                    type(value).__name__,repr(value)))
-        if '%' in key:
-            raise ValueError("Key \"%s\" contains a \"%\""%(key,))
-        if key in self.__parameters:
-            raise PTParserError("Attempted to redefine function argument \"%s\"."%(key,))
-        elif key in self.__const:
-            raise PTParserError("Attempted to redefine constant \"%s\"."%(key,))
-        self.__vars[key]=value
-        global over
-        try:
-            if key in self.__overrides:
-                for names,override in self.__overrides[key]:
-                    #print 'Check override %s %s'%(names[-1],override)
-                    subscope=self
-                    for name in [key]+names[0:-1]:
-                        subscope=subscope.resolve(name)
-                        assert(subscope.is_scope)
-                        if not subscope.is_scope:
-                            continue # raise KeyError(name)
-                    assert(isinstance(override,BaseObject))
-                    subscope.force_define(names[-1],override)
-                return override
-        except KeyError as ke:
-            raise
-        return value
-
-    def haslocal(self,key):
-        """!Is there a variable with this name?
-
-        Searches the parameter list, variable list, and constants list
-        for the given variable name.  The name must be local; it can
-        contain no "%"
-
-        @param key a local variable name (contains no "%")
-        @returns True if any variable is set with the given name.
-        """
-        return key in self.__parameters or key in self.__vars or \
-            key in self.__const
-
-    def iterlocal(self):
-        """!Iterates over all local variables in this order:
-        parameters, constants, variables"""
-        for k,v in self.__parameters.items():
-            yield k,v
-        for k,v in self.__const.items():
-            yield k,v
-        for k,v in self.__vars.items():
-            yield k,v
-
-    def resolve(self,key,scopes=None):
-        """!Given a path to a variable, return the variable.
-
-        Searches this scope and its containing scopes for the given
-        variable.  The variable can be a path to a variable
-        (containing "%") or a local variable (no "%").  If the scopes
-        parameter is given, then those scopes are treated as the
-        containing scopes; otherwise defscopes is used.
-
-        @param key a local variable (no "%") or a path to a variable
-        (containing "%")
-        @param scopes Optional.  Replaces defscopes as the containing
-        scopes to search if the variable is not defined in this
-        scope.
-        @returns a BaseObject for the requested variable
-        @raise KeyError if no such variable is defined"""
-        assert(isinstance(key,str))
-        names=splitkey(key)
-        con=fileless_context()
-        if scopes is None:
-            search=[self]+self.defscopes
-        else:
-            search=[self]+scopes
-        #scopestack=list()
-        # yell('search for %s = %s in %s\n'%(repr(key),repr(names),repr(search)))
-        for name in names:
-            found=None
-            for scope in search:
-                try:
-                    found=scope.getlocal(name)
-                    # if name=='TEST_NAME':
-                    #     print 'Found %s in scope %s = "%s" name "%s"'%(
-                    #         str(name),id(scope),elipses(scope.getlocal(
-                    #                 'TEST_DESCR').string_context(con)),
-                    #         scope.getlocal('TEST_NAME').string_context(con))
-                    #scopestack.insert(0,scope)
-                    break # Done searching scopes.
-                except KeyError as ke:
-                    # yell('Key %s not in scope %s from top %s\n'%(
-                    #         repr(name),repr(scope),repr(self)))
-                    continue # Check for name in next scope.
-            if found is None:
-                raise PTKeyError(key)
-            search=[found]
-        if found is None:
-            raise PTKeyError(key)
-        # if subscopes: 
-        #     return ( found, scopestack )
-        # else:
-        return found
-
-    def force_define(self,key,value,skip_constants=False):
-        """!Sets the value of a variable, replacing the value if a
-        variable is already defined with that name.
-
-        @param key the local variable name (must contain no "%")
-        @param value a valid rvalue (is_rvalue=True)
-        @param skip_constants if True, the variable is NOT overridden
-        if it is already defined as a constant
-
-        @returns the value, or None if no action was performed.  That
-        can happen if skip_constants is True, and the name corresponds
-        to a constant."""
-        names=splitkey(key)
-        lval=self
-        for i in range(len(names)-1):
-            lval=lval.getlocal(names[i])
-        if skip_constants and lval.get_type(names[-1])=='constant':
-            #module_logger.info('Do not redefine %s.'%(key,))
-            return None
-        assert(names[-1]!='TEST_NAME')
-        lval.setlocal(names[-1],value)
-        return value
-
-    def check_define(self,key,value):
-        """!Defines a local variable, raising an exception if a
-        variable is already defined with the given name.
-
-        @param key the local variable name (no "%")
-        @param value a BaseObject that is a valid rvalue (is_rvalue=True)
-        @returns value"""
-        names=splitkey(key)
-        lval=self
-        for i in range(len(names)-1):
-            lval=lval.subscope(names[i])
-        assert(names[-1]!='TEST_NAME')
-        if lval.haslocal(value):
-            raise PTParserError('Symbol %s is already declared in this scope.'%(key,))
-        #yell('setlocal %s = %s\n'%(names[-1],value))
-        lval.setlocal(names[-1],value)
-        return value
-
-    def expand_string(self,string,con,scopes=None):
-        """!Performs string expansion.
-
-        Expands escape characters and variable references in a string.  
-
-        @param string a python string to expand
-        @param con the Context in which this object is being evaluated
-        @param scopes sent to resolve(); these scopes will be searched instead
-        of defscopes when a variable is not found in this scope.
-        @returns the resulting python string"""
-        stream=io.StringIO()
-        # if string.find('TEST_NAME')>-1:
-        #     print 'Expand "%s"'%(elipses(string,max_length=80),)
-        # yell('Expand %s in %s\n'%(repr(string),repr(self)))
-        def streamwrite(s):
-            #yell("Append \"%s\" to output string.\n"%(s,))
-            stream.write(s)
-        for m in re.finditer(r'''(?sx)
-            (
-                (?P<text>[^@]+)
-              | @ \[ (?P<escaped_at>@ ) \]
-              | @ \[ ' (?P<escaped_text> [^']+ ) ' \]
-              | @ \[ (?P<varexpr>[^\]]+) \]
-              | (?P<literal_at>@ ) (?! \[ )
-              | (?P<error>.)
-            )''',string):
-            if m.group('text'):
-                streamwrite(m.group())
-            elif m.group('escaped_text'):
-                streamwrite(m.group('escaped_text'))
-            elif m.group('escaped_at'):
-                streamwrite(m.group('escaped_at'))
-            elif m.group('literal_at'):
-                streamwrite(m.group('literal_at'))
-            elif m.group('varexpr'):
-                streamwrite(self.resolve(m.group('varexpr'),scopes) \
-                                .string_context(con))
-            else:
-                raise ValueError("Parser error: invalid character \"%s\" in"
-                                 " \"%s\"\n"%(m.group(0),string))
-        val=stream.getvalue()
-        # if string.find('TEST_NAME')>-1:
-        #     print 'Result "%s"'%(elipses(val,max_length=120),)
-            #assert(val.find('nmm_cntrl')==-1)
-        stream.close()
-        return val
-
-def make_params(defscopes,**kwargs):
-    """!Returns a new Scope with the given parameter list (function
-    call definition)
-
-    @param defscopes the new Scope's defining or calling location; a
-    list of Scopes.  This will be copied into the defscopes member
-    variable.
-    @param kwargs (key,value) pairs mapping parameter name to the BaseObject value
-    @returns a new Scope representing the given function definition"""
-    s=Scope(defscopes)
-    for k,v in kwargs.items():
-        s.setlocal(k,v)
-    return s.as_parameters()
-
-def make_scope(defscopes,**kwargs):
-    """!Creates a new scope with local variables defined
-
-    @param defscopes the new Scope's defining or calling location; a
-    list of Scopes.  This will be copied into the defscopes member
-    variable.
-    @param kwargs (key,value) pairs mapping variable name to the BaseObject value
-    @returns a new Scope representing the given hash definition"""
-    for scope in defscopes:
-        if not isinstance(scope,Scope):
-            raise TypeError('In make_scope, the defscopes must be a list '
-                            'of Scope objects.  One of them is a %s %s'%(
-                                type(scope).__name__,repr(scope)))
-    s=Scope(defscopes)
-    for k,v in kwargs.items():
-        s.setlocal(k,v)
-    return s
-
-def call_scope(scope,con,defscopes,**kwargs):
-    """!Implements a function call.
-
-    @param scope the function to call
-    @param con Unused.  This Context is passed to Scope.apply_parameters().
-    @param defscopes the call stack to the location at which the
-    function call is made
-    @param kwargs arguments to the function call.  These will override
-    default values set in scope.
-    @returns the function call, as a Scope"""
-    parms=make_scope(defscopes,**kwargs)
-    assert(parms.no_nulls())
-    s=scope.apply_parameters(parms,con)
-    assert(s.no_nulls())
-    return s
-    
-########################################################################
-
-class Builtin(Scope):
-    """!An abstract base class that represents a built-in operator,
-    such as bit-wise comparison."""
-    def __init__(self,defscopes,opname):
-        """!Builtin constructor
-
-        @param defscopes a stack of Scopes to the point at which the
-        operator is defined, innermost Scope first.
-        @param opname the string name of the operator        """
-        super(Builtin,self).__init__(defscopes)
-        self.__opname=opname
-    def bash_context(self,con):
-        """!Raises TypeError to indicate that the operator cannot be
-        expressed in bash code."""
-        raise TypeError('Cannot evaluate built-in operator %s in a '
-                        'bash context.'%(self.__opname,))
-    def string_context(self,con):
-        """!Raises TypeError to indicate that the operator cannot be
-        expressed as a string."""
-        raise TypeError('Cannot evaluate built-in operator %s in a '
-                        'string context.'%(self.__opname,))
-    def logical_context(self,con):
-        """!Raises TypeError to indicate that the operator cannot be
-        expressed as a logical value."""
-        raise TypeError('Cannot evaluate built-in operator %s in a '
-                        'logical context.'%(self.__opname,))
-    def numeric_context(self,con):
-        """!Raises TypeError to indicate that the operator cannot be
-        expressed as a numeric value."""
-        raise TypeError('Cannot evaluate built-in operator %s in a '
-                        'numeric context.'%(self.__opname,))
-    def getcom(self,con):
-        """!Returns the COM directory for the test that contains this
-        operation.
-
-        Walks up the nested scopes from inner to outer, searching for
-        the innermost Test (detected via BaseObject.is_test).  When
-        found, asks the test to resolve the "COM" symbol, and returns
-        the result of that objects string_context function.
-
-        @param con a Context from which this function is called
-
-        @returns The COM directory for the innermost test in the
-        defscopes as a string."""
-        for scope in self.defscopes:
-            if scope.is_test:
-                return scope.resolve('COM').string_context(con)
-        raise PTKeyError('COM')
-
-    def run(self,con):
-        """!Raises TypeError to indicate that the operator cannot be executed"""
-        raise TypeError('Cannot run built-in operator %s.'%(self.__opname,))
-
-    def __str__(self):
-        return '(%s %s %s)'%(
-            str(self.resolve('src')), self.__opname, str(self.resolve('tgt')))
-
-    def new_empty(self):
-        """!Returns a copy of self."""
-        return Builtin(self.defscopes,self.__opname)
-
-########################################################################
-
-class Copy(Builtin):
-    """!An operator that represents file copying."""
-    def __init__(self,defscopes,empty=False):
-        """!Constructor for Copy
-        @param defscopes a stack of Scope objects to the point at which this Copy was defined, innermost Scope first
-        @param empty if True, the "src" and "tgt" parameters will be
-        set to the null_value.  If False, no variables will be set."""
-        super(Copy,self).__init__(defscopes,'.copy.')
-        if not empty:
-            self._set_parameters({'src':null_value, 'tgt':null_value})
-    def new_empty(self):
-        """!Creates a new, empty Copy object defined in the same
-        location (defining stack of Scope objects) as self.
-        @returns the new Copy"""
-        return Copy(self.defscopes,empty=True)
-    def run(self,con):
-        """!Executes the copy using produtil.fileop.deliver_file()
-        @param con the Context in which this object is being evaluated
-        @returns None"""
-        assert(self.no_nulls())
-        src=self.resolve('src').string_context(con)
-        tgt=self.resolve('tgt').string_context(con)
-        produtil.fileop.deliver_file(src,tgt)
-    def bash_context(self,con):
-        """!Returns bash code that would execute the copy
-        @param con the Context in which this object is being evaluated
-        @returns the bash code in a string"""
-        assert(self.no_nulls())
-        src=self.resolve('src').bash_context(con)
-        tgt=self.resolve('tgt').bash_context(con)
-        return 'deliver_file %s %s\n'%(src,tgt)
-
-########################################################################
-
-class CopyDir(Builtin):
-    """!Represents a copy of a set of files from a source directory to
-    the local directory.  The operator source (src) is the directory
-    from which to copy, and the operator target (tgt) is a glob for
-    the files in that directory to copy."""
-    def __init__(self,defscopes,empty=False):
-        """!Constructor for CopyDir
-        @param defscopes a stack of Scope objects to the point at which this CopyDir was defined, innermost Scope first
-        @param empty if True, the "src" and "tgt" parameters will be
-        set to the null_value.  If False, no variables will be set."""
-        super(CopyDir,self).__init__(defscopes,'.copydir.')
-        if not empty:
-            self._set_parameters({'src':null_value, 'tgt':null_value})
-    def new_empty(self):
-        """!Creates a new, empty CopyDir object defined in the same
-        location (defining stack of Scope objects) as self.
-        @returns the new CopyDir"""
-        return CopyDir(self.defscopes,empty=True)
-    def run(self,con):
-        """!Not implemented; raises NotImplementedError"""
-        raise NotImplementedError('CopyDir.run is not implemented yet.')
-    def bash_context(self,con):
-        """!Generates bash code that will copy the specified files.
-        @param con the Context in which this object is being evaluated
-        @returns the bash code as a string"""
-        assert(self.no_nulls())
-        src=self.resolve('src').bash_context(con)
-        tgt=self.resolve('tgt').string_context(con)
-        return '''
-(
-  shopt -u failglob ;
-  shopt -s nullglob ;
-  glob='%s'/$( basename '%s' )
-  tgtdir=$( dirname '%s' )
-  mkdir -p "$tgtdir"
-  for srcfile in $glob ; do
-    deliver_file "$srcfile" "$tgtdir/$( basename $srcfile )" ;
-  done
-)
-'''%(src,tgt,tgt)
-
-########################################################################
-
-class Link(Builtin):
-    """!An operator that represents creation of a symbolic link.  The
-    source ("src") is the name of the link and the target ("tgt") is
-    the file to link to."""
-    def __init__(self,defscopes,empty=False):
-        """!Constructor for Link
-        @param defscopes a stack of Scope objects to the point at which this Link was defined, innermost Scope first
-        @param empty if True, the "src" and "tgt" parameters will be
-        set to the null_value.  If False, no variables will be set."""
-        super(Link,self).__init__(defscopes,'.link.')
-        if not empty:
-            self._set_parameters({'src':null_value, 'tgt':null_value})
-    def new_empty(self):
-        """!Creates a new, empty Link object defined in the same
-        location (defining stack of Scope objects) as self.
-        @returns the new Link"""
-        return Link(self.defscopes,empty=True)
-    def run(self,con):
-        """!Makes the symbolic link using produtil.fileop.make_symlink"""
-        assert(self.no_nulls())
-        src=self.resolve('src').string_context(con)
-        tgt=self.resolve('tgt').string_context(con)
-        produtil.fileop.make_symlink(src,tgt)
-    def bash_context(self,con):
-        """!Generates bash code that will make the symlink
-        @param con the Context in which this object is being evaluated
-        @returns the bash code as a string"""
-        assert(self.no_nulls())
-        src=self.resolve('src').bash_context(con)
-        tgt=self.resolve('tgt').bash_context(con)
-        return 'rm -f %s\nln -sf %s %s\n'%(tgt,src,tgt)
-
-########################################################################
-
-class AtParse(Builtin):
-    """!Represents the "atparse" command, which parses files,
-    converting \@[varname] constructs into the variable's value.  The
-    "src" variable is the *.IN file passed into atparse, while the
-    "tgt" is the output file for the parsed value."""
-    def __init__(self,defscopes,empty=False):
-        """!Constructor for AtParse
-        @param defscopes a stack of Scope objects to the point at which this AtParse was defined, innermost Scope first
-        @param empty if True, the "src" and "tgt" parameters will be
-        set to the null_value.  If False, no variables will be set."""
-        super(AtParse,self).__init__(defscopes,'.atparse.')
-        if not empty:
-            self._set_parameters({'src':null_value, 'tgt':null_value})
-    def new_empty(self):
-        """!Returns a new, empty, AtParse with the defining scopes
-        (defscopes) the same as self."""
-        return AtParse(self.defscopes,empty=True)
-    def run(self,con):
-        """!Raises NotImplementedError to indicate AtParse.run() is
-        not implemented yet.
-        @param con the Context in which this object is being evaluated"""
-        raise NotImplementedError('You cannot "run" an atparse object.')
-    def bash_context(self,con):
-        """!Generates a block of bash code that will parse the file.
-        @param con the Context in which this object is being evaluated
-        @returns the resulting block of bash code"""
-        out=io.StringIO()
-        src=self.resolve('src').bash_context(con)
-        tgt=self.resolve('tgt').bash_context(con)
-        out.write("echo input to atparse from %s:\ncat %s\n"%(src,src))
-        out.write("echo send to %s\n"%(tgt,))
-        out.write("cat %s | atparse \\\n"%(src,))
-        seen=set()
-        for scope in self.defscopes:
-            for k,v in scope.iterlocal():
-                if k in seen: continue
-                seen.add(k)
-                if '%' in k or '.' in k:
-                    pass#out.write('# $%s: skip; invalid shell variable name\n'%(k,))
-                elif k[0:2] == '__':
-                    pass#out.write("# $%s: skip; name begins with __\n"%(k,))
-                elif v is null_value:
-                    pass#out.write('# $%s: skip; has no value\n'%(k,))
-                elif not v.is_scalar:
-                    pass#out.write('# $%s: skip; value is not scalar\n'%(k,))
-                else:
-                    out.write('  %s=%s \\\n'%(k,v.bash_context(con)))
-        out.write("  > %s\n"%(tgt,))
-        if con.verbose:
-            out.write("set -xe\n")
-        else:
-            out.write("set -e\n")
-        out.write('cat %s\n\n'%(tgt,))
-        ret=out.getvalue()
-        out.close()
-        return ret
-
-########################################################################
-
-class BitCmp(Builtin):
-    """!Represents a bit-for-bit comparison between two files, as is
-    done by the "cmp" shell command.  The "src" and "tgt" variables
-    are the two files to compare"""
-    def __init__(self,defscopes,empty=False):
-        """!Constructor for BitCmp
-        @param defscopes a stack of Scope objects to the point at which this BitCmp was defined, innermost Scope first
-        @param empty if True, the "src" and "tgt" parameters will be
-        set to the null_value.  If False, no variables will be set."""
-        super(BitCmp,self).__init__(defscopes,'.bitcmp.')
-        if not empty:
-            self._set_parameters({'src':null_value, 'tgt':null_value})
-    def new_empty(self):
-        """!Creates a new, empty BitCmp object defined in the same
-        location (defining stack of Scope objects) as self.
-        @returns the new BitCmp"""
-        return BitCmp(self.defscopes,empty=True)
-    def run(self,con):
-        """!Executes the bit-for-bit comparison
-        @returns True if the files match and False if they do not.  
-        @param con the Context in which this object is being evaluated"""
-        src=self.resolve('src').string_context(con)
-        tgt=self.resolve('tgt').string_context(con)
-        if con.run_mode==BASELINE:
-            produtil.fileop.deliver_file(src,tgt)
-            return
-        if os.path.samefile(src,tgt):
-            # Same file object in filesystems.
-            return True
-        with open(src,'rt') as srcf:
-            with open(tgt,'rt') as tgtf:
-                srcstat=os.fstat(src.fileno())
-                tgtstat=os.fstat(tgt.fileno())
-                if not srcstat: return False # file stopped existing
-                if not tgtstat: return False # file stopped existing
-                if srcstat.st_size!=tgtstat.st_size:
-                    # Different size according to stat
-                    return False
-                eof=False
-                while not eof:
-                    srcdat=src.read(1048576)
-                    tgtdat=tgt.read(1048576)
-                    if len(srcdat)!=len(tgtdat):
-                        return False # Lengths differ
-                    if srcdat!=tgtdat:
-                        return False # Contents differ
-                    eof=not len(srcdat) or not len(tgtdat)
-                return True
-    def bash_context(self,con):
-        """!Generates bash code that compares the two files and copies
-        the source file to com.
-
-        @param con the Context in which this object is being evaluated"""
-        src=self.resolve('src').bash_context(con)
-        tgt=self.resolve('tgt').bash_context(con)
-        comdir=bashify_string(self.getcom(con))
-
-        if con.run_mode==BASELINE:
-            return 'deliver_file %s %s\n'%(tgt,src) + \
-                   'deliver_file %s %s/%s\n'%(tgt,comdir,tgt)
-        else:
-            return '''deliver_file %s %s/%s\n
-set +e # bitcmp failures are reported by report_failed\nbitcmp %s %s\nset -e\n'''%(
-                tgt,comdir,tgt, # deliver_file $tgt $compath
-                tgt,src)     # bitcmp $tgt $src
-
-########################################################################
-
-class NccmpVars(Builtin):
-    """!Represents a bit-for-bit comparison between two files, as is
-    done by the "cmp" shell command.  The "src" and "tgt" variables
-    are the two files to compare"""
-    def __init__(self,defscopes,empty=False):
-        """!Constructor for NccmpVars
-        
-       @param defscopes a stack of Scope objects to the point at which
-       this BitCmp was defined, innermost Scope first
-        
-        @param empty if True, the "src" and "tgt" parameters will be
-        set to the null_value.  If False, no variables will be set."""
-        super(NccmpVars,self).__init__(defscopes,'.nccmp_vars.')
-        if not empty:
-            self._set_parameters({'src':null_value, 'tgt':null_value})
-    def new_empty(self):
-        """!Creates a new, empty BitCmp object defined in the same
-        location (defining stack of Scope objects) as self.
-        @returns the new BitCmp"""
-        return NccmpVars(self.defscopes,empty=True)
-    def bash_context(self,con):
-        """!Generates bash code that compares the two files and copies
-        the source file to com.
-
-        @param con the Context in which this object is being evaluated"""
-        src=self.resolve('src').bash_context(con)
-        tgt=self.resolve('tgt').bash_context(con)
-        comdir=bashify_string(self.getcom(con))
-
-        if con.run_mode==BASELINE:
-            return 'deliver_file %s %s\n'%(tgt,src) + \
-                   'deliver_file %s %s/%s\n'%(tgt,comdir,tgt)
-        else:
-            return '''deliver_file %s %s/%s\n
-set +e # nccmp failures are reported by report_failed\nnccmp_vars %s %s\nset -e\n'''%(
-                tgt,comdir,tgt, # deliver_file $tgt $compath
-                tgt,src)     # bitcmp $tgt $src
-
-########################################################################
-
-class Md5Cmp(Builtin):
-    """!A class that will use store an MD5 sum of an executable for
-    later validation."""
-    def __init__(self,defscopes,empty=False):
-        """!Constructor for Md5Cmp
-        @param defscopes a stack of Scope objects to the point at which this Md5Cmp was defined, innermost Scope first
-        @param empty if True, the "src" and "tgt" parameters will be
-        set to the null_value.  If False, no variables will be set."""
-        super(Md5Cmp,self).__init__(defscopes,'.md5cmp.')
-        if not empty:
-            self._set_parameters({'src':null_value, 'tgt':null_value})
-    def new_empty(self):
-        """!Creates a new, empty Md5Cmp object defined in the same
-        location (defining stack of Scope objects) as self.
-        @returns the new CopyDir"""
-        return Md5Cmp(self.defscopes,empty=True)
-    def run(self,con):
-        """!Raises Md5Cmp to indicated this function is not yet implemented"""
-        raise NotImplementedError("Md5Cmp.run is not implemented.")
-    def bash_context(self,con):
-        """!Generates a block of bash code that will compute and store
-        the md5sum.  The executable is the "tgt" variable and the
-        reference MD5 sum is the "src" variable.  The new MD5 sum is
-        stored in the COM directory as the executable basename with
-        ".md5" appended.
-        @param con the Context in which this object is being evaluated
-        @returns the resulting bash code block"""
-        md5ref=self.resolve('src').string_context(con) # reference md5sum
-        exe=self.resolve('tgt').string_context(con) # executable
-        md5sum=os.path.join(self.getcom(con),
-                            os.path.basename(md5ref))
-        md5ref=bashify_string(md5ref)
-        exe=bashify_string(exe)
-        md5sum=bashify_string(md5sum)
-        # Behaves the same way in baseline and verification mode
-        # because this is checking the executable used during the run
-        return '''md5sum {exe} > {md5sum}
-report_line md5sum: $( cat {md5sum} )
-report_line md5sum "local="{md5sum}
-report_line md5sum "reference="{md5ref}
-'''.format(
-            md5ref=md5ref,md5sum=md5sum,exe=exe)
-
-########################################################################
-
-class Criteria(TypelessObject):
-    """!Represents a list of output validation criteria."""
-    def __init__(self,defscopes):
-        """Criteria constructor
-        @param defscopes a stack of Scope objects to the point at which this Criteria was defined, innermost Scope first
-        """
-        super(Criteria,self).__init__(defscopes)
-        self.__opmap=collections.defaultdict(list)
-        self.__tgtlist=list()
-        self.is_criteria=True
-    def __str__(self):
-        s='Criteria:'
-        for tgt in self.__tgtlist:
-            s+=' '+str(tgt)+': (/ '
-            s+= ', '.join(type(callme).__name__+':'+str(callme) for callme in self.__opmap[tgt])
-            s+=' /),'
-        return s
-    def add_binary_operator(self,tgt,op,src,con):
-        """!Adds a binary operator criterion that compares src and tgt.
-
-        @param tgt The target of the comparison, which represents the
-        "known correct value" such as baseline data or an executable
-        MD5 sum
-
-        @param op the operaton to perform, a Scope.
-        @param src The source of the comparison, an unknown or uncertain
-        value to compare against "src".  Generally, the "src" is copied to COM.
-        @param con the Context in which this object is being evaluated
-        @returns None"""
-        if tgt not in self.__opmap:
-            self.__tgtlist.append(tgt)
-        callme=call_scope(op,con,self.defscopes,tgt=tgt,src=src)
-        for mycall in self.__opmap[tgt]:
-            assert mycall is not null_value
-            if mycall==callme:
-                return
-        callme=self.__opmap[tgt].append(callme)
-        assert callme is not null_value
-    def rescope(self,scopemap=None,prepend=None):
-        """!Modifies this object's scopes, and that of any subobjects.
-
-        Subclasses that can be expressed as non-constant values must
-        implement this function for rescoping.  This function changes
-        the stack of defining scopes, defscopes, based on arguments
-
-        @param scopemap a mapping from old Scope to new Scope during
-        the replacement
-
-        @param prepend a list of Scope objects to prepend.  These
-        become the innermost scopes.  The scopemap is NOT applied to
-        the prepend list.
-        @returns self"""
-        if prepend is None: prepend=[]
-        if scopemap is None: scopemap={}
-        f=Criteria(prepend+[ scopemap[s] if s in scopemap else s
-                        for s in self.defscopes ])
-        assert(self.__tgtlist)
-        for tgt in self.__tgtlist:
-            for callme in self.__opmap[tgt]:
-                assert(callme)
-            rtgt=tgt.rescope(scopemap,prepend)
-            f.__tgtlist.append(rtgt)
-            f.__opmap[rtgt]=[ 
-                callme.rescope(scopemap,prepend)
-                for callme in self.__opmap[tgt] ]
-        assert(f.__tgtlist)
-        assert(f.__opmap)
-        return f
-    def _apply_rescope(self,scopemap=None,prepend=None):
-        """!Replaces Scope objects in this object's defscopes variable.
-
-        This function is the internal implementation of the "use"
-        blocks and function calls when parsing or evaluating.
-        Subclasses with a rescope() or similar function use
-        _apply_rescope() to implement such functions.
-
-        @param scopemap A mapping from old Scope to new Scope
-        @param prepend A list of Scope objects to prepend to defscopes
-        @protected"""
-        super(Criteria,self)._apply_rescope(scopemap,prepend)
-        for tgt in self.__tgtlist:
-            tgt._apply_rescope(scopemap,prepend)
-            for callme in self.__opmap[tgt]:
-                callme._apply_rescope(scopemap,prepend)
-    def use_from(self,criteria,only_scalars=False):
-        """!Implements a "use" statement; copies definitions from another Scope
-
-        Copies parameters, constants, and variables from another scope
-        into this one.  Copies are modified to have this scope in
-        their definition or calling stack via the rescope() function.
-
-        @param used_scope The scope whose data is being copied.
-        @param only_scalars If True, then only the objects with
-        is_scalar=True are copied.
-        @returns True if all variables seen were scalar, False if any
-        non-scalar variables were seen.  This includes variables that
-        were found, but not "used," due to only_scalars=True"""
-        if only_scalars:
-            raise ValueError('In Criteria.use_from, only_scalars must '
-                             'be False.')
-        if not criteria.is_criteria:
-            raise TypeError('Criteria blocks can only use criteria blocks.')
-        for tgt,callme in criteria.itercriteria():
-            found=False
-            for mycall in self.__opmap[tgt]:
-                if callme==mycall:
-                    found=True
-                    break
-            if not found: 
-                self.__opmap[tgt].append(callme)
-                self.__tgtlist.append(tgt)
-        assert(self.__tgtlist)
-        assert(self.__opmap)
-    def itercriteria(self):
-        """!Iterates over all  (tgt,criterion) pairs in this Criteria."""
-        for tgt in self.__tgtlist:
-            for callme in self.__opmap[tgt]:
-                yield tgt,callme
-    def bash_context(self,con):
-        """!Generates a bash code block that will perform all criteria
-        comparisons or baseline comparisons
-        @param con the Context in which this object is being evaluated
-        @returns the new bash code block."""
-        out=io.StringIO()
-        if con.run_mode==BASELINE:
-            out.write('\n########################################################################\necho BASELINE GENERATION:\n\n')
-        else:
-            out.write('\n########################################################################\necho OUTPUT VALIDATION:\n\n')
-        assert(self.__tgtlist)
-        for tgt in self.__tgtlist:
-            out.write('echo criteria for target %s:\n'%(
-                      tgt.bash_context(con),))
-            for callme in self.__opmap[tgt]:
-                out.write(callme.bash_context(con))
-                if con.run_mode==BASELINE: break
-        if con.run_mode==BASELINE:
-            out.write('\necho END OF BASELINE GENERATION\n########################################################################\n\n')
-        else:
-            out.write('\necho END OF OUTPUT VALIDATION\n########################################################################\n\n')
-        ret=out.getvalue()
-        out.close()
-        return ret
-
-########################################################################
-
-class Filters(TypelessObject):
-    """!Represents a list of input filters to run in sequence.  These
-    use some "src" object, and a filter (binary operator) to generate
-    the "tgt" object."""
-    def __init__(self,defscopes):
-        """!Constructor for Filters
-        @param defscopes a stack of Scope objects to the point at which this Filters was defined, innermost Scope first"""
-        super(Filters,self).__init__(defscopes)
-        self.__opmap=dict()
-        self.__tgtlist=list()
-        self.is_filters=True
-    def add_binary_operator(self,tgt,op,src,con):
-        """!Adds a filter that compares src and tgt.
-
-        @param tgt The target of the filter; the local file that is created.
-
-        @param op the operaton to perform, a Scope.
-        @param src The source of the file, generally a file or set of files
-        @param con the Context in which this object is being evaluated
-        @returns None"""
-        if tgt not in self.__opmap:
-            self.__tgtlist.append(tgt)
-        self.__opmap[tgt]=call_scope(op,con,self.defscopes,
-                                     tgt=tgt,src=src)
-        assert self.__opmap[tgt] is not null_value
-    def rescope(self,scopemap=None,prepend=None):
-        """!Modifies this object's scopes, and that of any subobjects.
-
-        Subclasses that can be expressed as non-constant values must
-        implement this function for rescoping.  This function changes
-        the stack of defining scopes, defscopes, based on arguments
-
-        @param scopemap a mapping from old Scope to new Scope during
-        the replacement
-
-        @param prepend a list of Scope objects to prepend.  These
-        become the innermost scopes.  The scopemap is NOT applied to
-        the prepend list.
-        @returns self"""
-        if prepend is None: prepend=[]
-        if scopemap is None: scopemap={}
-        f=Filters(prepend+[ scopemap[s] if s in scopemap else s
-                        for s in self.defscopes ])
-        for tgt in self.__tgtlist:
-            rtgt=tgt.rescope(scopemap,prepend)
-            f.__tgtlist.append(rtgt)
-            f.__opmap[rtgt]=self.__opmap[tgt].rescope(scopemap,prepend)
-        return f
-    def _apply_rescope(self,scopemap=None,prepend=None):
-        """!Replaces Scope objects in this object's defscopes variable.
-
-        This function is the internal implementation of the "use"
-        blocks and function calls when parsing or evaluating.
-        Subclasses with a rescope() or similar function use
-        _apply_rescope() to implement such functions.
-
-        @param scopemap A mapping from old Scope to new Scope
-        @param prepend A list of Scope objects to prepend to defscopes
-        @protected"""
-        super(Filters,self)._apply_rescope(scopemap,prepend)
-        for tgt in self.__tgtlist:
-            tgt._apply_rescope(scopemap,prepend)
-    def use_from(self,filters,only_scalars=False):
-        """!Implements a "use" statement; copies definitions from another Scope
-
-        Copies parameters, constants, and variables from another scope
-        into this one.  Copies are modified to have this scope in
-        their definition or calling stack via the rescope() function.
-
-        @param used_scope The scope whose data is being copied.
-        @param only_scalars If True, then only the objects with
-        is_scalar=True are copied.
-        @returns True if all variables seen were scalar, False if any
-        non-scalar variables were seen.  This includes variables that
-        were found, but not "used," due to only_scalars=True"""
-        if only_scalars:
-            raise ValueError('In Filters.use_from, only_scalars must '
-                             'be False.')
-        if not filters.is_filters:
-            raise TypeError('Filters blocks can only use filters blocks.')
-        for tgt,callme in filters.iterfilters():
-            have_tgt=tgt in self.__opmap
-            if have_tgt and self.__opmap[tgt]==callme:
-                continue
-            self.__opmap[tgt]=callme
-            assert self.__opmap[tgt] is not null_value
-            if not have_tgt:
-                self.__tgtlist.append(tgt)
-    def iterfilters(self):
-        for tgt in self.__tgtlist:
-            yield tgt,self.__opmap[tgt]
-    def bash_context(self,con):
-        """!Generates a bash code block that executes all filters in sequence
-        @param con the Context in which this object is being evaluated
-        @returns the resulting bash code as a string."""
-        out=io.StringIO()
-        out.write('\n########################################################################\necho INPUT FILTERS:\n\n')
-        for tgt in self.__tgtlist:
-            # out.write('echo Filter for target %s:\n'%(
-            #         tgt.bash_context(con),))
-            out.write(self.__opmap[tgt].bash_context(con))
-        out.write('\necho END OF INPUT FILTERS\n########################################################################\n\n')
-        ret=out.getvalue()
-        out.close()
-        return ret
-
-########################################################################
-
-class Rank(TypelessObject):
-    """!Represents a single MPI rank or group of MPI ranks with
-    identical resource requirements and executable.  This is merely a
-    container class to store information for a SpawnProcess object."""
-    def __init__(self,args,opts):
-        """!Constructor for Rank
-
-        @param args The executable (args[0]) and its arguments (args[1:])
-        @param opts The options, a dict.  The meanings of the keys is defined by the SpawnProcess class."""
-        self.__args=list(args)
-        self.__opts=opts
-        self._fields=dict()
-
-    def init_fields(self,con):
-        if self._fields: return
-        f={ 'ranks':         max(0,self._getnum(con,'ranks',-1)),
-            'cpus_per_core': self._getnum(con,'cpus_per_core',-1),
-            'ppn':           max(0,self._getnum(con,'ppn',0)),
-            'threads':       max(1,self._getnum(con,'threads',0))  }
-        f['nonzero_ppn']=f['ppn']
-        if f['cpus_per_core']<0:
-            f['cpus_per_core']=self._getres(con,'plat%cpus_per_core',1)
-        if not f['ppn']:
-            cores_per_node=con.scopes[-1].resolve('plat%cores_per_node').\
-                numeric_context(con)
-            f['nonzero_ppn']=cores_per_node//f['threads']
-        self._fields=f
-
-    def ranks(self,con):
-        self.init_fields(con)
-        return self._fields['ranks']
-
-    def cpus_per_core(self,con):
-        self.init_fields(con)
-        return self._fields['cpus_per_core']
-
-    def ppn(self,con):
-        self.init_fields(con)
-        return self._fields['ppn']
-
-    def threads(self,con):
-        self.init_fields(con)
-        return self._fields['threads']
-
-    def _getnum(self,con,key,default):
-        if self.__opts is None or not self.__opts.haslocal(key):
-            return default
-        return int(self.__opts.getlocal(key).numeric_context(con))
-
-    def _getres(self,con,key,default):
-        try:
-            return int(self.__opts.resolve('plat%cpus_per_core').numeric_context(con))
-        except KeyError:
-            return default
-
-    def __repr__(self):
-        return 'Rank(args=%s,opts=%s)'%(
-            repr(self.__args),repr(self.__opts))
-
-    def new_empty(self):
-        return Rank(list(),None)
-
-    def rescope(self,scopemap=None,prepend=None):
-        n=self.new_empty()
-        n.__args=[ a.rescope(scopemap,prepend) for a in self.__args ]
-        n.__opts=self.__opts.rescope(scopemap,prepend)
-        return n
-
-    ##@property args
-    # A list containing the executable (args[0]) and its arguments (args[1:])
-
-    def merge_into(self,con,others):
-        self.init_fields(con)
-        f=self._fields
-        me={'ranks':max(1, f['ranks']),
-            'args': list(self.__args),
-            'cpus_per_core': max(1, f['cpus_per_core']),
-            'ppn': max(0,f['nonzero_ppn']),
-            'threads': f['threads'] }
-
-        if not others: return [me]
-
-        last=others[-1]
-        if last['args']          == me['args'] and \
-           last['cpus_per_core'] == me['cpus_per_core'] and \
-           last['ppn']           == me['nonzero_ppn'] and \
-           last['threads']       == me['threads']:
-            others[-1]['ranks']  += me['ranks']
-        else:
-            others.append(me)
-        return others
-
-    @property
-    def args(self):
-        """!A list containing the executable (args[0]) and its
-        arguments (args[1:])"""
-        return self.__args
-
-    def argiter(self):
-        """!Iterates over executable and arguments in the args member
-        variable"""
-        for arg in self.__args:
-            yield arg
-
-########################################################################
-
-def pack_ranks(nodesize,count):
-    """!Spreads count MPI ranks over the fewest possible nodes whose
-    maximum PETs per node (ppn) is nodesize.  Attempts to distribute
-    the ranks per node as equally as possible.  Any node will never
-    have more than one or less than one rank than any other node.
-
-    @returns a list of two-element lists.  Each two element list
-    contains a pair [number of nodes, PETs per node (ppn)] for nodes
-    that have an identical number of PETs per node (ppn)
-    @param nodesize the maximum number of PETS per node of any given compute node
-    @param count the number of MPI ranks"""
-    out=list()
-    n=count
-    if n<nodesize:  # special case: smaller than one node
-        out.append([1,n])
-    elif nodesize*(n//nodesize)==n: #exact number of nodes
-        out.append([n//nodesize,nodesize])
-    else:
-        need=math.ceil(n/float(nodesize))
-        averagef=n/math.ceil(need)
-        af,ai = math.modf(averagef)
-        n1=need-round(af*need)
-        n2=round(af*need)
-        if n1: out.append([n1, ai])
-        if n2: out.append([n2, ai+1])
-    return out
-
-########################################################################
-
-def expand_lists(iterable,max_depth=None):
-    for i in iterable:
-        if isinstance(i,list) or isinstance(i,tuple):
-            if max_depth is None:
-                for k in expand_lists(i): 
-                    yield k
-            elif max_depth>=0:
-                for k in expand_lists(i,max_depth-1):
-                    yield k
-            else:
-                yield i
-        else:
-            yield i
-
-########################################################################
-
-class SpawnProcess(TypelessObject):
-    """!Represents a request to execute a process.  This process may
-    be OpenMP, serial, MPI, or MPI+OpenMP.  This is the implementation
-    of the "spawn" block."""
-    def __init__(self,defscopes):
-        """!SpawnProcess constructor
-        @param defscopes a stack of Scope objects to the point at which this SpawnProcess was defined, innermost Scope first"""
-        super(SpawnProcess,self).__init__(defscopes)
-        self.__ranks=list()
-    def new_empty(self):
-        return SpawnProcess(self.defscopes)
-    def rescope(self,scopemap=None,prepend=None):
-        n=self.new_empty()
-        n.__ranks=[ rank.rescope(scopemap,prepend) for rank in self.__ranks ]
-        return n
-    def add_rank(self,args,opts):
-        """!Adds an MPI rank or block of MPI ranks, or serial program,
-        or OpenMP program, to the SpawnProcess.
-
-        Generates and stores a Rank object that contains the
-        information in args and opts
-
-        @param args the executable (args[0]) and command-line arguments (args[1:])
-        @param opts the other options in the "spawn" block."""
-        assert(isinstance(args,list))
-        self.__ranks.append(Rank(args,opts))
-    def iterrank(self):
-        """!Iterates over all Rank objects generated by add_rank() calls."""
-        for rank in self.__ranks:
-            yield rank
-    def mpi_comm_size(self,con):
-        """!Computes the size of MPI_COMM_WORLD
-
-        Analyzes all Rank objects created by add_rank() calls,
-        calculating the number of MPI ranks requested.  Note that this
-        includes ranks from all executables in an Multiple Program
-        Multiple Data (MPMD) execution (executions with multiple
-        executables in a single MPI_COMM_WORLD)
-
-        @returns the size of MPI_COMM_WORLD, or 0 if this is not an MPI program.
-        @param con the Context in which this object is being evaluated"""
-        size=0
-        for rank in self.__ranks:
-            size+=rank.ranks(con)
-        return size
-
-    def _make_nodes_ppn(self,con):
-        rank_info=list()
-        for rank in self.__ranks:
-            rank_info=rank.merge_into(con,rank_info)
-        MPI=con.scopes[-1].resolve('plat%MPI').string_context(con)
-
-        min_cpus_per_core=max(1, min([ r['cpus_per_core'] for r in rank_info ]))
-        max_ppn_tpn=max(1, max([ r['ppn']*r['threads'] for r in rank_info ]))
-        max_ppn=max(1, max([ r['ppn'] for r in rank_info ]))
-        num_pets=max(1, sum([ r['ranks'] for r in rank_info ]))
-        max_threads=max(1, max([ r['threads'] for r in rank_info ]))
-        cores_per_node=con.scopes[-1].resolve('plat%cores_per_node').\
-            numeric_context(con)
-        assert(cores_per_node>0)
-
-        # (nodes, ppn) pairs for blocks of similar nodes:
-        packed=[ pack_ranks(r['ppn'],r['ranks']) for r in rank_info ]
-        nodes=sum([ pr[0] for pr in expand_lists(packed,0) ])
-
-        # Determine the acting node size:
-        nodesize=cores_per_node # ideally, the number of cores
-        affinity='core'
-        if max_ppn_tpn>nodesize:
-            # If it is bigger than that, try the number of cpus.
-            nodesize=min_cpus_per_core*cores_per_node 
-            affinity='cpu'
-        if max_ppn_tpn>nodesize:
-            # Caller wants to overcommit a node.  This usually fails,
-            # but we'll try to request it anyway.  
-            nodesize=max(nodesize,max_ppn_tpn)
-
-        return MPI,nodesize,affinity,max_threads,nodes,max_ppn_tpn,max_ppn,packed
-
-    def rocoto_resources(self,con):
-        MPI,nodesize,affinity,max_threads,nodes,max_ppn_tpn,max_ppn,packed=\
-            self._make_nodes_ppn(con)
-        request=''
-
-        if MPI.upper().find('LSF')>=0:
-            request+="<nodesize>%d</nodesize>\n"%nodesize
-            if MPI.upper().find('CRAY_INTEL')<0:
-                request+="<native>-R 'affinity[%s(%d)]'</native>\n"%(
-                    affinity, max_threads)
-            elif nodes>1:
-                request+="<nodes>%d:ppn=%d</nodes>\n"%(nodes,max_ppn_tpn)
-
-        if max_ppn<2:
-            # For serial jobs, use 2 cores to ensure exclusive access to node.
-            request+="<cores>2</cores>\n"%max_ppn
-        elif nodes<2:
-            # For single node jobs, use the <cores> syntax.
-            request+="<cores>%d</cores>\n"%max_ppn
-        elif MPI.upper().find('LSF_CRAY_INTEL')<0:
-            # For multi-node jobs, use the <nodes> syntax.  We exclude
-            # LSF_CRAY_INTEL because it has a different method.
-            nodespecs=[ '%d:ppn=%d'%(int(p[0]),int(p[1])) for p in expand_lists(packed,0) ]
-            request+='<nodes>' + ('+'.join(nodespecs)) + '</nodes>\n'
-
-        return request
-        
-    def bash_context(self,con):
-        """!Generates a bash code block to run the specified program
-
-        @param con the Context in which this object is being evaluated
-        @returns a bash code block to run the program."""
-        MPI,nodesize,affinity,max_threads,nodes,max_ppn_tpn,max_ppn,packed=\
-            self._make_nodes_ppn(con)
-
-        out=io.StringIO()
-        out.write('# Embedded process execution:\n')
-        need_ranks=len(self.__ranks)>1
-        have_ranks=False
-        ranks=list()
-        threads=list()
-        for rank in self.__ranks:
-            nranks=rank.ranks(con)
-            if nranks>0: have_ranks=True
-            if nranks<1 and need_ranks:
-                nranks=1
-            ranks.append(nranks)
-            threads.append(rank.threads(con))
-            con.info('Rank block: threads=%s ranks=%s'%(repr(threads[-1]),
-                                                          repr(ranks[-1])))
-        nthreads=max(1,max(threads))
-        out.write('export OMP_NUM_THREADS=%d MKL_NUM_THREADS=0\n'%(
-                nthreads,))
-        if not have_ranks:
-            # Serial or openmp program.
-            out.write(' '.join([r.bash_context(con) 
-                                for r in self.__ranks[0].args]))
-            out.write('\n')
-        else:
-            out.write('%s\n'%(con.mpirunner(self,distribution=packed[0]),))
-        out.write('# End of embedded process execution.\n')
-        ret=out.getvalue()
-        out.close()
-        return ret
-
-########################################################################
-
-class EmbedBash(Scope):
-    """!Represents an embedded bash script.  This is the
-    implementation of the "embed bash [[[code]]]" block."""
-    def __init__(self,defscopes):
-        """!Constructor for EmbedBash
-        @param defscopes a stack of Scope objects to the point at which this EmbedBash was defined, innermost Scope first"""
-        super(EmbedBash,self).__init__(defscopes)
-        self.__template=None
-    def __bool__(self):
-        return bool(self.__template)
-    def validate_parameter(self,name):
-        """!Does nothing; this is a placeholder for variable name validation
-
-        This function analyzes the given variable name and raises an
-        exception if the variable name is invalid.  Presently, any
-        variable name is valid, so this function is a no-op.  However,
-        any variable name that contains a period (".") will not be
-        passed in to generated bash code as a bash variable.
-
-        @param name the name of a new parameter (function argument) to validate.
-        @returns None"""
-        pass
-        #if not re.match('(?s)^[a-zA-Z][a-zA-Z0-9_]*$',name):
-            #raise ValueError('Invalid bash variable name $%s FIXME: use better exception here'%(name,))
-
-    def bash_context(self,con):
-        """!Raises an exception to indicate that the bash script
-        cannot be represented as a bash string.
-        @param con the Context in which this object is being evaluated"""
-        raise PTParserError("Cannot express bash script in a bash string.")
-
-    def _apply_rescope(self,scopemap=None,prepend=None):
-        """!Replaces Scope objects in this object's defscopes variable.
-
-        This function is the internal implementation of the "use"
-        blocks and function calls when parsing or evaluating.
-        Subclasses with a rescope() or similar function use
-        _apply_rescope() to implement such functions.
-
-        @param scopemap A mapping from old Scope to new Scope
-        @param prepend A list of Scope objects to prepend to defscopes
-        @protected"""
-        super(EmbedBash,self)._apply_rescope(scopemap,prepend)
-        self.__template._apply_rescope(scopemap,prepend)
-        self.__template.defscopes=[self]+self.defscopes
-
-    def rescope(self,scopemap=None,prepend=None):
-        """!Modifies this object's scopes, and that of any subobjects.
-
-        Subclasses that can be expressed as non-constant values must
-        implement this function for rescoping.  This function changes
-        the stack of defining scopes, defscopes, based on arguments
-
-        @param scopemap a mapping from old Scope to new Scope during
-        the replacement
-
-        @param prepend a list of Scope objects to prepend.  These
-        become the innermost scopes.  The scopemap is NOT applied to
-        the prepend list.
-        @returns self"""
-        s=super(EmbedBash,self).rescope(scopemap,prepend)
-        s.__template=self.__template.rescope(scopemap,prepend)
-        s.__template.defscopes=[self]+self.defscopes
-        return s
-
-    def __str__(self):
-        return "bash script \"%s\" %s"%(
-            elipses(repr(self.gettemplate())),
-            super(EmbedBash,self).__str__())
-
-    def __repr__(self):
-        return "bash script \"%s\" %s"%(
-            elipses(repr(self.gettemplate())),
-            super(EmbedBash,self).__str__())
-
-    def apply_parameters(self,scope,con):
-        """!Implements a function call using this Scope as the parameter list.
-
-        Creates a new Scope where all parameters in this scope are
-        converted to local variables and possibly overridden.  Scope
-        self's parameters are used for the default argument values.
-        The "scope" argument to apply_parameters() contains values to
-        override those.  Hence, self is the function definition and
-        scope is the values set in the function call.  
-
-        A third Scope is created, containing the result of applying
-        the function call and default values.  That third Scope has no
-        parameters; all parameters have been converted to local
-        values.  The returned Scope has the same defscopes as self.
-        That means any unresolved variables within the function will
-        be resolved in the defining context, NOT the calling context.
-
-        @param scope The arguments provided to the function call.
-        @param con the Context at which this function is being called.
-           The defining location is in defscopes.
-        @returns a Scope representing the function call."""
-        s=super(EmbedBash,self).apply_parameters(scope,con)
-        s.__template=self.__template.rescope({self:s, scope:s})
-        assert(s.__template)
-        s.__template.defscopes=[self]+self.defscopes
-        return s
-
-    def is_valid_rvalue(self,con):
-        """!Can this EmbedBash object be assigned to a variable?
-
-        An EmbedBash definition and function call can always be
-        assigned to a variable.  However, the result of
-        apply_parameters() (also an EmbedBash object) cannot be.
-
-        @returns True if this EmbedBash can be assigned to a variable,
-        or False otherwise.
-        @param con the Context in which this object is being evaluated"""
-        return self.__template is not None
-
-    def string_context(self,con): 
-        """!Evaluates this EmbedBash in a string context.
-
-        Executes this EmbedBash via run(), converts the result to a
-        number (via numeric_context()) and then to a string via "%d" 
-
-        @param con the Context in which this object is being evaluated
-        @returns the string copy of the numeric result of run()"""
-        return '%d'%(self.numeric_context(con),)
-
-    def settemplate(self,template):
-        """!Sets the scope used for string expansion of the embedded
-        bash script.
-
-        The embedded bash script's string expansion has a special
-        Scope stack when it is evaluated.
-
-        1. Function arguments are searched first. These function
-        arguments are the result of applying the function call
-        arguments to the function definition argument list (and
-        default arguments).
-
-        2. Defining scopes above the function definition are searched
-        next.
-
-        The settemplate sets the Scope used for this search.
-        @param template the calling context
-        @returns None"""
-        assert(isinstance(template,String))
-        self.__template=template
-        self.__template.defscopes=[self]+self.defscopes
-
-    def gettemplate(self):
-        """!Returns the template that should be used for string
-        expansion of the embedded bash script"""
-        return self.__template
-
-    def numeric_context(self,con):
-        """!Executes the bash script, returning the result as a numeric value"""
-        return self.run(con)
-
-    def bash_context(self,con):
-        """!Generates and returns a bash code block to run the
-        embedded script with the script variables set to the function
-        arguments.
-
-        Generates a bash code block that sets bash local variables
-        variables to the calling arguments.  Any variables whose names
-        contain "." or "%" will not be set since they are not valid
-        bash variable names.  Next, the code block contains the
-        embedded bash code.  Finally, it will unset the local
-        variables set in the first step.
-
-        @param con the Context in which this object is being evaluated
-        @returns the resulting bash code"""
-        template=self.gettemplate()
-        template.defscopes=[self]+self.defscopes # workaround for unknown bug
-        expanded=template.string_context(con)
-        #template=template.string_context(con)
-        #expanded=self.expand_string(template,con)
-
-        stream=io.StringIO()
-        env=dict()
-        unset_me=list()
-        
-        set_pre=''
-        try:
-            if self.getlocal('export.vars').logical_context(con):
-                set_pre='export '
-        except KeyError as ke: pass
-
-        for k,v in self.iterlocal():
-            if '%' in k or '.' in k:
-                stream.write('# $%s: skip; invalid shell variable name\n'
-                             %(k,))
-            elif k[0:2] == '__':
-                stream.write("# $%s: skip; name begins with __\n"%(k,))
-            elif v is null_value:
-                stream.write('# $%s: skip; has no value\n'%(k,))
-            elif not v.is_scalar:
-                stream.write('# $%s: skip; value is not scalar\n'%(k,))
-            else:
-                unset_me.append(k)
-                stream.write('%s%s=%s\n'%(set_pre,k,v.bash_context(con)))
-        stream.write("# Embedded bash script:\n")
-        stream.write(expanded)
-        stream.write('\n# End of embedded bash script.\n')
-        for k in unset_me:
-            stream.write('unset %s\n'%(k,))
-        if con.verbose:
-            stream.write('set -xe\n\n')
-        else:
-            stream.write('set -e\n\n')
-        script=stream.getvalue()
-        stream.close()
-        return script
-
-    def run(self,con):
-        """!Runs the script generated by bash_context()
-
-        Uses produtil.run.run() and produtil.run.exe() to execute this
-        bash code block.  
-
-        @returns the result of produtil.run.run()
-
-        @note Since produtil.run.exe() is used, the program will be
-        run as a "large" or "compute" program.  On Cray, this means
-        the program will be run via "aprun," placing it on a compute
-        node.
-
-        @param con the Context in which this object is being evaluated
-        @"""
-
-        con.info('%s: run %s'%(str(con),elipses(str(self))))
-
-        script=self.bash_context(con)
-        # yell('%-7s %-7s %s\n'%("RUN","BASH",script))
-        cmd=produtil.run.batchexe("bash")
-        if con.verbose:
-            cmd=cmd<<'set -xue\n'+script
-        else:
-            cmd=cmd<<'set -ue\n'+script
-        env=dict(self.iterlocal())
-        if env: cmd.env(**env)
-        return produtil.run.run(cmd)
-            
-    def logical_context(self,con): 
-        """!Executes this EmbedBash, returning True if the script
-        returns a 0 status, and False otherwise.
-
-        Uses run() to execute this program, via numeric_context() to
-        get the numeric return value.  
-
-        @returns True if the script return value was 0, False otherwise
-        @param con the Context in which this object is being evaluated"""
-        return bool(self.numeric_context(con)==0)
-
-    def new_empty(self):
-        """!Creates a new, empty EmbedBash object defined in the same
-        location (defining stack of Scope objects) as self.
-        @returns the new EmbedBash"""
-        s=EmbedBash(self.defscopes)
-        s.__template=self.__template.rescope({self:s})
-        assert(s.__template)
-        return s
-
-########################################################################
-
-class Task(Scope):
-    """!Represents a task that has a name, and can be executed as a
-    batch job.  The task may, optionally, have dependencies on other
-    tasks."""
-    def __init__(self,defscopes,name,runvar='run'):
-        """!Constructor for Task
-
-        @param defscopes a stack of Scope objects to the point at which this Task was defined, innermost Scope first
-        @param name the name of this task
-        @param runvar the name of the variable that is executed to run this Task"""
-        super(Task,self).__init__(defscopes)
-        self.__deps=list()
-        self.__name=str(name)
-        self.runvar=runvar
-
-    ##@property name
-    # the name of this task
-
-    @property
-    def name(self):
-        """!The name of this task"""
-        return self.__name
-    def bash_context(self,con):
-        """!Represents this task as a bash code block
-
-        Represents the variable self.runvar in a bash context within
-        the Context con.  That bash code block is used as the bash
-        representation of this Task.
-
-        @returns the bash code that represents runvar in a bash context"""
-        assert(self.haslocal(self.runvar))
-        return self.getlocal(self.runvar).bash_context(con)
-
-    def iterdeps(self):
-        """!Iterates over all dependencies that were added via add_dependency()"""
-        for dep in self.__deps:
-            yield dep
-
-    def add_dependency(self,dep):
-        """!Adds the given dependency to the list of dependencies for this task.
-
-        @param dep a Task that must be run before this task"""
-        self.__deps.append(dep)
-
-    def is_valid_rvalue(self,con):
-        """!Can this Task be assigned to a variable?
-
-        Determines if this task can be assigned to a variable.  For
-        that to be done, the Task must be able to be run.  That is, it
-        must have its runvar assigned and non-null.
-
-        @param con the Context in which this object is being evaluated
-        @return True if this task can be assigned to a variable, False otherwise"""
-        return self.haslocal(self.runvar) and \
-            self.getlocal(self.runvar) is not null_value
-
-    def string_context(self,con): 
-        """!Generates a string that represents this Task
-
-        Calls runvar's string_context function and returns that as
-        this Task's string representation.
-
-        @param con the Context in which this object is being evaluated
-        @returns a string representation of runvar"""
-        return self.getlocal(self.runvar).string_context(con)
-
-    def numeric_context(self,scopes,con):
-        """!Generates a number that represents this Task
-
-        Calls runvar's numeric_context function and returns that as
-        this Task's numeric representation.
-
-        @param con the Context in which this object is being evaluated
-        @returns a numeric representation of runvar"""
-        return self.getlocal(self.runvar).numeric_context(con)
-
-    def run(self,con):
-        """!Executes this task.
-
-        Runs the run function of runvar, returning the result.
-
-        @return the result of runvar's run function"""
-        return self.getlocal(self.runvar).run(con)
-            
-    def logical_context(self,con): 
-        """!Generates a number that represents this Task
-
-        Calls runvar's numeric_context function and returns that as
-        this Task's numeric representation.
-
-        @param con the Context in which this object is being evaluated
-        @returns a numeric representation of runvar"""
-        return self.getlocal(self.runvar).numeric_context(con)
-
-    def new_empty(self):
-        """!Creates an identical copy of this task, but without dependencies.
-
-        Uses the Task constructor to copy this task but omits the dependency list.
-
-        @returns the resulting Task"""
-        return Task(self.defscopes,self.__name,self.runvar)
-
-########################################################################
-
-class Build(Task):
-    """!A Task that represents a build process (anything that
-    constructs a program to be executed)."""
-    def __init__(self,defscopes,name):
-        """!Constructor for Build.
-
-        @param defscopes a stack of Scope objects to the point at
-        which this Build was defined, innermost Scope first
-        @param name the name of this Build"""
-        super(Build,self).__init__(defscopes,name,'build')
-    def new_empty(self):
-        """!Creates an identical copy of this build, but without dependencies.
-
-        Uses the Task constructor to copy this build but omits the dependency list.
-
-        @returns the resulting Build"""
-        return Build(self.defscopes,self.name)
-
-########################################################################
-
-class Platform(Task):
-    """!Represents a Task whose job is to determine the local platform."""
-    def __init__(self,defscopes,name):
-        """!Constructor for Platform.
-
-        @param defscopes a stack of Scope objects to the point at
-        which this Platform was defined, innermost Scope first
-        @param name the name of this Platform"""
-        super(Platform,self).__init__(defscopes,name,'detect')
-    def new_empty(self):
-        """!Creates an identical copy of this platform, but without dependencies.
-
-        Uses the Task constructor to copy this platform but omits the dependency list.
-
-        @returns the resulting Platform"""
-        return Platform(self.defscopes,self.name)
-
-########################################################################
-
-class Test(Scope):
-    """!A Task that represents some Test to be run.  Generally the
-    Test copies input files, runs some program or script, and
-    validates against a baseline (or creates a new baseline)."""
-    def __init__(self,defscopes,name,mode):
-        """!Constructor for Test
-        @param defscopes a stack of Scope objects to the point at which this Test was defined, innermost Scope first
-        @param name the name of this Test
-        @param mode produtil.testing.utilities.BASELINE or produtil.testing.utilities.EXECUTION"""
-        super(Test,self).__init__(defscopes)
-        assert(mode in [ BASELINE, EXECUTION ])
-        self.mode=mode
-        self.__name=str(name)
-        self.__deps=list()
-        self.is_test=True
-
-    ##@var name
-    # The name of this Test
-
-    @property
-    def name(self):
-        """!The name of this test."""
-        return self.__name
-
-    def bash_context(self,con):
-        """!Generates a bash script that will run this test.
-
-        Generates a bash script by running the bash_context functions
-        of each of these steps, taken from resolve():
-
-        1. prep - prepares the environment for execution
-        2. input - obtains input data
-        3. execute - executes the test
-        4. One of:
-            a. make_baseline - creates a new baseline from the output of the above three steps
-            b. verify - compares the output of the above three steps against the baseline
-
-        If either "make_baseline" or "verify" is unavailable, then the
-        "output" variable from resolve() is used in their place.  If
-        that is also unavailable, KeyError is raised.
-
-        @param con the Context in which this object is being evaluated
-        @raise KeyError if one of the required variables is undefined
-        @returns the resulting  bash code        """
-        if self.mode==BASELINE:
-            steps=['prep','input','prerun','execute','make_baseline']
-        else:
-            steps=['prep','input','prerun','execute','verify']
-
-        name=self.resolve("TEST_NAME").bash_context(con)
-        try:
-            descr=self.resolve("TEST_DESCR").bash_context(con)
-        except KeyError as ke:
-            descr='no description'
-        report=self.resolve("COM").bash_context(con)
-        report=os.path.join(report,'report.txt')
-
-        out=io.StringIO()
-        out.write("report_start %s Test %s starting at $( date ) '('%s')'\n"%(
-                report,name,descr))
-        for step in steps:
-            try:
-                stepobj=self.getlocal(step)
-            except KeyError as ke:
-                if step in [ 'make_baseline', 'verify' ]:
-                    stepobj=self.getlocal('output')
-                elif step in [ 'prerun', 'input' ]:
-                    continue # prerun and input steps are optional
-                else:
-                    raise
-            out.write(stepobj.bash_context(con))
-            out.write('\n')
-        out.write("report_finish\n")
-        ret=out.getvalue()
-        out.close()
-        return ret
-
-    def iterdeps(self):
-        """!Iterates over this Test's dependencies"""
-        for dep in self.__deps:
-            yield dep
-
-    def add_dependency(self,dep):
-        """!Adds a Task that must be executed before this Task
-        @param dep the Task to be executed"""
-        self.__deps.append(dep)
-
-    def is_valid_rvalue(self,con):
-        """!Can this Test be assigned to a variable
-
-        Checks to see if all variables needed by bash_context() are defined
-
-        In BASELINE mode: prep, input, execute and either make_baseline or output
-        In EXECUTION mode: prep, input, execute, and either verify or output
-
-        @param con the Context in which this object is being evaluated"""
-        if self.mode==BASELINE:
-            steps=['prep','input','execute','make_baseline']
-        else:
-            steps=['prep','input','execute','verify']
-
-        for step in steps:
-            if self.haslocal(step):
-                if self.getlocal(step) is not null_value:
-                    continue
-            elif step in ['make_baseline','verify'] and \
-                    self.haslocal('output'):
-                if self.getlocal('output') is not null_value:
-                    continue
-            raise PTParserError('Compset is missing the step: '+step)
-        return True
-
-    def string_context(self,con): 
-        """!Raises TypeError to indicate that a test cannot be evaluated
-        @param con the Context in which this object is being evaluated"""
-        raise TypeError('A Test cannot be evaluated in a string context.')
-
-    def numeric_context(self,con):
-        """!Raises TypeError to indicate that a test cannot be evaluated
-        @param con the Context in which this object is being evaluated"""
-        raise TypeError('A Test cannot be evaluated in a numeric context.')
-
-    def run(self,con):
-        """!Raises TypeError to indicate that a test cannot be evaluated
-        @param con the Context in which this object is being evaluated"""
-        raise TypeError('A Test cannot be run directly.')
-            
-    def logical_context(self,con): 
-        """!Raises TypeError to indicate that a test cannot be evaluated
-        @param con the Context in which this object is being evaluated"""
-        raise TypeError('A Test cannot be evaluated in a logical context.')
-
-    def new_empty(self):
-        """!Creates a Test that is identical to this one, but without
-        dependencies.
-
-        Uses the Test.__init__() constructor to make a new Test that
-        is identical to this one, but without dependencies
-
-        @returns the copied Test"""
-        return Test(self.defscopes,self.name,self.mode)
-
-########################################################################
-
-class AutoDetectPlatform(object):
-    """!Uses a list of Platform objects to detect the local platform.
-    This involves running scripts at parse time.  This is the
-    implementation of the "autodetect" command."""
-    def __init__(self):
-        """!Constructor for AutoDetectPlatform"""
-        super(AutoDetectPlatform,self).__init__()
-        self.__platforms=list()
-    def add(self,platform):
-        """!Adds a Platform to the list of platforms to use for detection"""
-        self.__platforms.append(platform)
-    def detect(self,con):
-        """!Returns the list of Platform objects detected on this machine.
-
-        Resolves "detect" via Platform.resolve() on all platforms
-        given to add().  Evaluates the resulting values in a logical
-        context, and constructs a list with all Platform objects whose
-        logical context is True.  
-
-        @param con the Context in which this object is being evaluated
-        @returns the list of detected platforms.  This list will be
-        empty if no platforms are detected."""
-        matches=list()
-        names=list()
-        for platform in self.__platforms:
-            detecter=platform.resolve('detect')
-            name=platform.resolve('PLATFORM_NAME')
-            name=name.string_context(con)
-            con.info('%s: detection...'%(name,))
-            detection=detecter.logical_context(con)
-            if detection:
-                con.info('%s: PLATFORM DETECTED'%(name,))
-                matches.append(platform)
-                names.append(name)
-            else:
-                con.info('%s: not detected'%(name,))
-        con.info('List of platforms detected: '+
-                 ' '.join([ repr(s) for s in names ]))
-        return matches
-
-########################################################################
-
-class Numeric(BaseObject):
-    """!Represents a numeric literal.  This may be a real or integer value"""
-    def __init__(self,value):
-        """!Constructor for Numeric
-        @param value The value, a float or int."""
-        super(Numeric,self).__init__([])
-        self.is_scalar=True
-        self.__value=value
-    def string_context(self,con):
-        """!Uses "%g" to convert this Numeric's value to a string.
-        @param con the Context in which this object is being evaluated
-        @returns the resulting string"""
-        return '%g'%self.__value
-    def bash_context(self,con):
-        """!Uses "%g" to convert this Numeric's value to a bash code block.
-        @param con the Context in which this object is being evaluated
-        @returns the resulting string"""
-        return '"%g"'%self.__value
-    def numeric_context(self,con):
-        """!The value of this Numeric.
-        @returns the value sent to the constructor."""
-        return self.__value
-    def logical_context(self,con):
-        """!Is the value 0?
-
-        @returns False if the value of this Numeric is identically 0,
-        or True if it is not."""
-        return self.numeric_context(con)!=0
-    def __str__(self):
-        return str(self.__value)
-    def __repr__(self):
-        return repr(self.__value)
-    def rescope(self,scopemap=None,prepend=None): 
-        """!Returns a copy of self
-        @param scopemap ignored
-        @param prepend ignored"""
-        return Numeric(self.__value)
-    
-########################################################################
-
-class String(BaseObject):
-    """!Represents a string literal."""
-    def __init__(self,defscopes,value,should_expand):
-        """!Constructor for String
-
-        @param defscopes a stack of Scope objects to the point at
-        which this String was defined, innermost Scope first.  This is
-        used for string expansion.
-
-        @param value the string value
-        @param should_expand if True, the string should be expanded
-        when evaluated.  If False, the string value is returned
-        without expansion."""
-        super(String,self).__init__(defscopes)
-        self.__value=str(value)
-        self.is_scalar=True
-        self.should_expand=bool(should_expand)
-    def rescope(self,scopemap=None,prepend=None):
-        """!Modifies this object's scopes, and that of any subobjects.
-
-        Subclasses that can be expressed as non-constant values must
-        implement this function for rescoping.  This function changes
-        the stack of defining scopes, defscopes, based on arguments
-
-        @param scopemap a mapping from old Scope to new Scope during
-        the replacement
-
-        @param prepend a list of Scope objects to prepend.  These
-        become the innermost scopes.  The scopemap is NOT applied to
-        the prepend list.
-        @returns self"""
-        if prepend is None: prepend=[]
-        if scopemap is None: scopemap={}
-        assert(isinstance(scopemap,dict))
-        assert(isinstance(prepend,list))
-        defscopes=list(prepend)
-        for s in self.defscopes:
-            assert(isinstance(s,Scope))
-            if s in scopemap:
-                defscopes.append(scopemap[s])
-            else:
-                defscopes.append(s)
-                # prepend+[ scopemap[s] if s in scopemap else s
-                #         for s in self.defscopes ],
-        return String(defscopes,
-                      self.__value,self.should_expand)
-    def string_context(self,con):
-        """!Returns this object in a string context.
-
-        Returns a string version of this String.  If should_expand is
-        True, then the string is expanded via Scope.expand_string().
-        Otherwise, the value is returned unmodified.
-
-        @param con the Context in which this object is being evaluated
-        @returns the resulting string"""
-        if self.should_expand:
-            return self.defscopes[0].expand_string(
-                self.__value,con,self.defscopes[1:])
-        else:
-            return self.__value
-    def bash_context(self,con):
-        """!Returns this string evaluated as a bash code block
-
-        Uses string_context() to evaluate this String in a string
-        context, which expands the string if needed.  Turns the result
-        into a bash string definition using
-        produtil.testing.utilities.bashify_string()
-
-        @returns a bash string literal representing this String."""
-        return bashify_string(self.string_context(con))
-    def logical_context(self,con):
-        """!Evaluates this string in a logical context.
-
-        Uses string_context() to evaluate this String in a string
-        context, which expands the string if needed.  Converts to a
-        logical by looking for one of the following values, case
-        insensitively:
-
-        - .true., true, yes, t, y: return True
-        - .false., false, no, f, n: return False
-        - anything else: raise ValueError
-
-        @return True or False if the contents of this string are
-        recognized as a logical value
-        @raise ValueError if the contents of this string are not
-        recognized as a logical value."""
-        s=self.string_context(con)
-        s=s[-30:].lower()
-        if s in [ '.true.', 'true', 'yes', 't', 'y' ]: return True
-        if s in [ '.false.', 'false', 'no', 'f', 'n' ]: return False
-        try:
-            i=float(s)
-        except ValueError as ve:
-            pass
-        raise ValueError('Cannot parse %s as a logical value.'%(s,))
-    def numeric_context(self,con):
-        """!Evaluates the string in a numeric context.
-
-        Uses string_context() to evaluate this String in a string
-        context, which expands the string if needed.  Converts to a
-        float using the Python built-in float() constructor.
-
-        @returns this string coerced to a float
-        @raise ValueError if float() does not recognize the value"""
-        s=self.string_context(con)
-        return float(s)
-    def __str__(self): return self.__value
-    def __repr__(self): return 'String(%s)'%(repr(self.__value),)
-    def __bool__(self):
-        return bool(self.__value)
-
-########################################################################
-
-class Environ(Scope):
-    """!A read-only Scope that represents os.environ"""
-    def __init__(self):
-        """!Constructor for Environ"""
-        super(Environ,self).__init__([])
-        self.can_be_used=False
-    def new_empty(self): 
-        """!Returns a new Environ via Environ.__init__()"""
-        return Environ()
-    def bash_context(self,con):
-        """!Raises an Exception to indicate that Environ cannot be
-        evaluated.
-        @param con the Context in which this object is being evaluated"""
-        raise PTParserError('Cannot express the environment in a bash context.')
-    def string_context(self,con):
-        """!Raises an Exception to indicate that Environ cannot be
-        evaluated.
-        @param con the Context in which this object is being evaluated"""
-        raise PTParserError('Cannot evaluate the environment in a string context.')
-    def no_nulls(self): return True
-    def _set_parameters(self,update):
-        """!Raises an Exception to indicate that Environ cannot be
-        modified.
-        @param con the Context in which this object is being evaluated"""
-        raise PTParserError('Cannot set parameters in the environment.')
-    def numeric_context(self,con):
-        """!Raises an Exception to indicate that Environ cannot be
-        evaluated.
-        @param con the Context in which this object is being evaluated"""
-        raise PTParserError('Cannot evaluate the environment in a numeric context.')
-    def logical_context(self,con):
-        """!Raises an Exception to indicate that Environ cannot be
-        evaluated.
-        @param con the Context in which this object is being evaluated"""
-        raise PTParserError('Cannot evaluate the environment in a logical context.')
-    def as_parameters(self,con):
-        """!Raises an Exception to indicate that Environ cannot be
-        modified.
-        @param con the Context in which this object is being evaluated"""
-        raise PTParserError('Cannot turn the environment into a parameter list.')
-    def rescope(self,scopemap=None,prepend=None):
-        """! Does nothing and returns self
-        @param scopemap ignored
-        @param prepend ignored
-        @returns self"""
-        return self
-    def has_parameters(self):
-        """!Returns False to indicate the environment contains no
-        parameters (function arguments)"""
-        return False
-    def use_from(self,used_scope,only_scalars=False):
-        """!Raises an exception to indicate that the environment
-        cannot be modified."""
-        raise PTParserError('Cannot use other scopes within the environment.')
-    def apply_parameters(self,scope,con):
-        """!Raises an exception to indicate that the environment cannot be executed"""
-        raise PTParserError('Cannot call the environment.')
-    def __str__(self):
-        return 'Environ()'
-    def __repr__(self):
-        return 'Environ()'
-    def subscope(self,key):
-        """!Raises an exception to indicate that the environment has no subscopes."""
-        raise TypeError('The environment has no subscopes.')
-    def getlocal(self,key):
-        """!Looks up the given environment variable.
-
-        Searches os.environ for the environment variable named in key.
-        Places the result in a String object with expand_string=False
-        (no string expansion).  Environment variables set to the null
-        string will have an empty String() returned.
-
-        @return the value of the environment variable as a String
-        @raise KeyError if the environment variable is not set"""
-        return String([self],os.environ[key],False)
-    def setlocal(self,key,value):
-        """!Raises an exception to indicate that the environment cannot be modified."""
-        raise PTParserError('Refusing to modify the environment.')
-    def haslocal(self,key):
-        """!Is this environment variable set?
-
-        Checks os.environ for the environment variable.  
-
-        @returns True if the environment variable is set, False
-        otherwise.  Environment variables that are set to the null
-        string are considered to be set, and will generate a True
-        return value."""
-        return key in os.environ
-    def iterlocal(self):
-        """!Iterates over the environment variables and their values
-
-        Iterates over the environment, yielding tuples containing the
-        environment variable name and its value.  Iteration is in the
-        order returned by os.environ.iteritems()"""
-        for k,v in os.environ.items():
-            yield k,String([self],v,False)
-    def resolve(self,key,scopes=None):
-        """!Gets the environment variable, returning it as a python string.
-
-        Searches for environment variables in os.environ.  It will
-        refuse to look up keys with "." or "%" in them.  Otherwise, it
-        is identical to os.environ.__getitem__()
-
-        @returns the environment variable's value as a string
-        @raise ValueError if the key contains "." or "%"
-        @raise KeyError if the environment variable is not set.  A
-        variable set to a null string is considered to be set, and
-        will not generate a KeyError."""
-        if '.' in key or '%' in key:
-            raise ValueError('Invalid environment variable \"%s\".'%(key,))
-        return os.environ[key]
-    def force_define(self,key,value):
-        """!Raises an exception to indicate that the environment cannot be modified."""
-        raise PTParserError('Refusing to modify the environment.')
-    def check_define(self,key,value):
-        """!Raises an exception to indicate that the environment cannot be modified."""
-        raise PTParserError('Refusing to modify the environment.')
diff --git a/produtil/testing/rocoto.py b/produtil/testing/rocoto.py
deleted file mode 100644
index e85aaa6eea..0000000000
--- a/produtil/testing/rocoto.py
+++ /dev/null
@@ -1,740 +0,0 @@
-"""!Takes an object tree from produtil.parse.Parser and turns it into
-a Rocoto workflow inside a valid Environmental Equivalence version 2
-(EE2) compliant vertical structure."""
-
-import sys, re, io, collections, os, datetime, logging
-import produtil.run, produtil.log, produtil.setup
-
-from produtil.testing.utilities import *
-from produtil.testing.script import bash_functions
-from produtil.testing.parsetree import Test, Build, BaseObject, SpawnProcess
-
-def to_rocoto_walltime(seconds):
-    return '%02d:%02d:%02d'%(
-        seconds//3600, (seconds//60)%60, (seconds//1)%60)
-
-def as_xml_attr(val):
-    return val.replace('&','&amp;').replace('<','&lt;') \
-              .replace('>','&gt;').replace('"','&quot;') \
-              .replace("'",'&apos;').replace('\n',' ')
-
-def as_xml_comment(val):
-    return val.replace('--',' - ').replace('<','&lt;') \
-        .replace('>','&gt;')
-
-########################################################################
-
-class RocotoTask(object):
-    """!Represents one task in a Rocoto workflow document"""
-    def __init__(self,name,obj,mode):
-        """!Constructor for RocotoTask
-
-        @param name the task name
-        @param obj a produtil.testing.parsetree.Task containing 
-          information about the task to run
-        @param mode the run mode: produtil.testing.utilities.BASELINE
-          or produtil.testing.utilities.EXECUTION"""
-        super(RocotoTask,self).__init__()
-        self.__name=name
-        self.__obj=obj
-        self.__mode=mode
-
-    ##@property mode
-    # The run mode: produtil.testing.utilities.BASELINE or
-    # produtil.testing.utilities.EXECUTION
-
-    @property
-    def mode(self):
-        """!The run mode: produtil.testing.utilities.BASELINE or
-          produtil.testing.utilities.EXECUTION"""
-        return self.__mode
-
-    def get_test_resources(self,con):
-        """!Get resource information for everything except cpus and
-        time.
-
-        Resolves the "test_size" variable to determine the test size.
-        Then looks for "plat%rocoto%{test_size}_test_resources" for
-        the resource information.  This is expected to contain
-        everything except cpus and runtime.
-
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @returns the resulting Rocoto XML code"""
-        try:
-            test_size=self.__obj.resolve('test_size')
-        except KeyError:
-            test_size='short'
-        return self.__obj.defscopes[-1].resolve(
-            'plat%rocoto%'+test_size+'_test_resources').string_context(con)
-    def get_walltime(self,con):
-        """!Gets walltime requirements from the "walltime" variable.
-
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @returns the resulting Rocoto XML code"""
-        try:
-            return '<walltime>%s</walltime>'%(
-                to_rocoto_walltime(self.__obj.resolve('walltime')
-                                   .numeric_context(con)),)
-        except KeyError as ke:
-            return '<walltime>%s</walltime>'%(
-                to_rocoto_walltime(self.__obj.defscopes[-1]
-                                   .resolve('plat%DEFAULT_TEST_WALLTIME')
-                                   .numeric_context(con)),)
-    def get_cpu_resources(self,con):
-        """!Gets execution resources from the "execute" variable,
-        resolving it in a rocoto_context.
-
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @returns the resulting Rocoto XML code"""
-        execute=self.__obj.resolve('execute')
-        if isinstance(execute,SpawnProcess):
-            s=execute.rocoto_resources(con)
-        else:
-            s='<cores>2</cores>'
-        return s
-    def j_job_name(self,workflow,con):
-        """!Generates a path to the task's j-job
-
-        Generates a path like "jobs/J{WORKFLOW}_{TASKNAME}" for the
-        j-job portion of the task.
-
-        @param workflow the RocotoWorkflow from which to obtain the
-        workflow name
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @returns the resulting path."""
-        return os.path.join(workflow.install_dir(con),'jobs',
-                            'J%s_%s'%(workflow.NAME,self.__name.upper()))
-    def ex_script_name(self,workflow,con):
-        """!Generates a path to the task's ex-script
-
-        Generates a path like "scripts/ex{workflow}_{taskname}" for the
-        ex-script portion of the task.
-
-        @param workflow the RocotoWorkflow from which to obtain the
-        workflow name
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @returns the resulting path."""
-        return os.path.join(workflow.install_dir(con),'scripts',
-                            'ex%s_%s'%(workflow.name,self.__name.lower()))
-    def j_job_contents(self,workflow,con):
-        """!Generates the contents of the Task's j-job
-        @param workflow the RocotoWorkflow from which to obtain the
-        workflow name
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @returns the contents of the j-job as a string"""
-        return r'''#! /usr/bin/env bash
-
-# DO NOT EDIT THIS SCRIPT; IT IS AUTOMATICALLY GENERATED
-
-{script}
-
-export HOME{workflow}="${{HOME{workflow}:-$RT_INSTALL_DIR}}"
-export USH{workflow}="${{USH{workflow}:-$HOME{workflow}/ush}}"
-export EX{workflow}="${{USH{workflow}:-$HOME{workflow}/scripts}}"
-
-{ex_script}
-'''.format(script=self.__obj.resolve('prep').bash_context(con),
-           workflow=workflow.name,WORKFLOW=workflow.NAME,
-           ex_script=self.ex_script_name(workflow,con))
-    def ex_script_contents(self,workflow,con):
-        """!Generates the contents of the Task's ex-script
-        @param workflow the RocotoWorkflow from which to obtain the
-        workflow name
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @returns the contents of the ex-script as a string"""
-        return r'''#! /usr/bin/env bash
-
-# DO NOT EDIT THIS SCRIPT; IT IS AUTOMATICALLY GENERATED
-
-source $HOME{workflow}/ush/functions.bash
-
-set -xe
-
-{SCRIPT}
-'''.format(SCRIPT=self.__obj.bash_context(con),
-           WORKFLOW=workflow.NAME,workflow=workflow.name)
-    def generate_xml(self,out,workflow,con):
-        """!Generates the Task's Rocoto XML element, writing it to
-          a file-like stream.
-
-        @param workflow the RocotoWorkflow from which to obtain the
-        workflow name
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @param out a file-like stream in which to write
-        @returns None"""
-        obj=self.__obj
-        if obj.haslocal('TEST_DESCR') and obj.haslocal('TEST_NAME'):
-            descr=as_xml_comment(obj.resolve('TEST_DESCR').string_context(con))
-            name=as_xml_comment(obj.resolve('TEST_NAME').string_context(con))
-            out.write('  <!-- Test %s: %s -->\n'%(name,descr))
-        out.write(r'''  <task name="{name}" maxtries="&TEST_MAXTRIES;">
-    <command>"&INSTALL_DIR;/jobs/J{WORKFLOW}_{NAME}"</command>
-    <jobname>rt_{name}</jobname>
-    <account>&ACCOUNT;</account>
-    {test_resources}
-    {cpu_resources}
-    {walltime}
-    <envar>
-      <name>{WORKFLOW}_INSTALL_DIR</name>
-      <value>&INSTALL_DIR;</value>
-    </envar>
-    <join>&LOG_DIR;/{name}.log</join>
-'''.format(name=self.__name,NAME=self.__name.upper(),
-           test_resources=self.get_test_resources(con),
-           cpu_resources=self.get_cpu_resources(con),
-           walltime=self.get_walltime(con),
-           WORKFLOW=workflow.name.upper()))
-        deps=[ dep for dep in self.__obj.iterdeps()]
-
-        if len(deps)>1 or self.mode is BASELINE:
-            out.write('    <dependency> <and>\n')
-        else:
-            out.write('    <dependency>\n')
-
-        if self.mode is BASELINE:
-            out.write('      <taskdep task="prep_baseline"/>\n')
-
-        if len(deps)==0 and self.mode is not BASELINE:
-            out.write('      <true/>\n')
-
-        for dep in deps:
-            if isinstance(dep,Build):
-                out.write('      <taskdep task="build_%s"/>\n'%(dep.name,))
-            elif isinstance(dep,Test):
-                out.write('      <taskdep task="test_%s"/>\n'%(dep.name,))
-
-        if len(deps)>1 or self.mode is BASELINE:
-            out.write('    </and> </dependency>\n')
-        else:
-            out.write('    </dependency>\n')
-
-        out.write(r'''  </task>
-
-''')
-
-########################################################################
-
-NODEFAULT=object()
-
-class RocotoWorkflow(object):
-    """!Represents a Rocoto workflow, and creates the files needed to
-    run one."""
-    def __init__(self,name,scope,mode):
-        """!Constructor for RocotoWorkflow
-
-        @param name The name of the workflow.
-        @param scope The global scope from produtil.testing.parser.Parse
-        @param mode the run mode: produtil.testing.utilities.BASELINE
-          or produtil.testing.utilities.EXECUTION
-        """
-        super(RocotoWorkflow,self).__init__()
-        if not is_valid_workflow_name(name):
-            raise PTParserError(
-                '%s: not a valid workflow name; must begin with a letter '
-                'and only contain alphanumerics and underscore.'%(name,))
-        self.name=name.lower()
-        self.mode=mode
-        self.NAME=name.upper()
-        self.cycle=datetime.datetime.now().strftime('%Y%m%d%H%M')
-        self.__scope=scope
-        self.__tasklist=list()
-        self.__taskdict=dict()
-        self.__buildlist=list()
-        self.__namemap=dict()
-        self.__files=dict()
-        self.__install=None
-        self.__uninstall=None
-        self.__end_build=r'''else
-  echo ERROR: Invalid build "$1" 1>&2
-  exit 1
-fi
-'''
-    def generate_install_script(self):
-        """!Generates the contents of the sorc/install.sh script.
-
-        Constructs a script that knows how to build any of the
-        possible build targets.  This is the contents of the
-        sorc/install.sh script.
-
-        @returns The resulting script, as a string."""
-        assert(self.__install is not None)
-        if self.__install is None:
-            return ''
-        else:
-            return self.__install.getvalue()+self.__end_build
-    def generate_uninstall_script(self):
-        """!Generates the contents of the sorc/uninstall.sh script.
-
-        Constructs a script that knows how to uninstall any of the
-        possible build targets.  This is the contents of the
-        sorc/uninstall.sh script.
-
-        @returns The resulting script, as a string."""
-        assert(self.__uninstall is not None)
-        if self.__uninstall is None:
-            return ''
-        else:
-            return self.__uninstall.getvalue()+self.__end_build
-    def has_builds(self):
-        """!Does this RocotoWorkflow contain any
-        produtil.testing.parsetree.Build objects?"""
-        return bool(self.__buildlist)
-    def getvar(self,var,default=NODEFAULT):
-        """!Resolves the specified variable reference within the
-        global scope
-
-        @param var A variable reference, such as "varname" or "scope1%scope2%varname" 
-        @returns The value of the variable as a produtil.testing.parsetree.BaseObject
-          or subclass thereof."""
-        try:
-            return self.__scope.resolve(var)
-        except KeyError as ke:
-            if default is not NODEFAULT:
-                return default
-            raise
-    def as_attr(self,var,con):
-        """!Resolves the specified variable reference in the given
-        context and returns its value quoted for an XML attribute.
-
-        Calls getvar() to resolve the variable, and expresses it
-        within a string context.  Quotes the resulting string for an
-        XML attribute.
-
-        @see as_xml_attr()
-        @see produtil.testing.parsetree.BaseObject.string_context()
-        @see produtil.testing.parsetree.Context """
-        val=self.getvar(var)
-        if isinstance(val,BaseObject):
-            val=val.string_context(con)
-        return as_xml_attr(val)
-    def run(self,obj,con):
-        """!Adds a RocotoTask to the RocotoWorkflow
-
-        @param obj a produtil.testing.parsetree.Test or
-        produtil.testing.parsetree.Build for which the RocotoTask is
-        to be constructed.
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables."""
-        if isinstance(obj,Test):
-            self.run_test(obj,con)
-        elif isinstance(obj,Build):
-            self.run_build(obj,con)
-        else:
-            raise PTParserError(
-                'Rocoto can only run Test and Build objects, not a %s %s.'%(
-                    type(obj).__name__,repr(obj)))
-    def run_test(self,test,con):
-        """!Adds the given produtil.testing.parsetree.Test to this
-        RocotoWorkflow as a test to execute.
-
-        @param test A produtil.testing.parsetree.Test representing the
-        test to run.
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables."""
-        self.add_test(test.name,test)
-        # FIXME: INSERT CODE HERE
-    def run_build(self,build,con):
-        """!Adds a build from the given
-        produtil.testing.parsetree.Build to this RocotoWorkflow as an
-        executable to build.
-
-        @param test The produtil.testing.parsetree.Build representing the
-          executable to build
-        @param con a produtil.testing.parsetree.Context to use when
-          resolving variables."""
-        self.add_build(build.name)
-
-        kwargs={ 'install_if':'elif',
-                 'uninstall_if':'elif',
-                 'name':build.name,
-                 'script':build.bash_context(con),
-                 'target':build.resolve('target').bash_context(con)
-                 }
-
-        if not self.__install:
-            self.__install=io.StringIO()
-            self.__install.write(r'''#! /usr/bin/env bash
-
-# DO NOT EDIT THIS SCRIPT; IT IS AUTOMATICALLY GENERATED
-# This script installs executables in the build_* jobs.
-
-set -xue
-
-''')
-            kwargs['install_if']='if'
-
-        if not self.__uninstall:
-            self.__uninstall=io.StringIO()
-            self.__uninstall.write(r'''#! /usr/bin/env bash
-
-# DO NOT EDIT THIS SCRIPT; IT IS AUTOMATICALLY GENERATED
-# This script uninstalls executables installed by the "install.sh" script.
-
-set -xue
-
-''')
-            kwargs['uninstall_if']='if'
-
-
-        self.__install.write(r'''
-{install_if} [[ "$1" == {name} ]] ; then
-########################################################################
-###### BUILD SCRIPT FOR TARGET {name}
-########################################################################
-rm -f {target}
-{script}
-set -xe
-test -s {target}
-test -x {target}
-'''.format(**kwargs))
-        self.__uninstall.write(r'''
-{uninstall_if} [[ "$1" == {name} ]] ; then
-rm -f {target}
-'''.format(**kwargs))
-
-
-    def add_file(self,path,contents):
-        """!Adds a file to the list of files that will be generated
-
-        @param path the path to the file
-        @param contents the text to write to the file"""
-        path=os.path.normpath(path)
-        if path in self.__files:
-            raise PTParserError('%s: tried to redefine contents for this file.'%(path,))
-        contents=str(contents)
-        self.__files[path]=contents
-    def add_build(self,buildname):
-        """!Adds the given build name to the list of known build names.
-
-        @param buildname the name of the build; this is used in the
-          executable names, module name, and arguments to install.sh
-          and uninstall.sh"""
-        if buildname in self.__buildlist:
-            raise PTParserError('%s: this build name is declared more than once.'%(buildname,))
-        self.__buildlist.append(buildname)
-    def add_test(self,taskname,obj):
-        """!Adds the given produtil.testing.parsetree.Test to this
-        RocotoWorkflow as a RocotoTask.
-
-        @param testname The string name of the test.
-        @param test A produtil.testing.parsetree.Test representing the
-        test to run.
-        @returns the resulting RocotoTask"""
-        assert(taskname[0:5]!='test_')
-        taskname='test_'+str(taskname)
-        if taskname in self.__taskdict:
-            raise PTParserError('%s: this task name is used more than once '%(taskname,))
-        task=RocotoTask(taskname,obj,self.mode)
-        self.__tasklist.append(taskname)
-        self.__taskdict[taskname]=task
-        return task
-    def iter_buildnames(self):
-        """!Iterates over build names."""
-        for buildname in self.__buildlist:
-            yield buildname
-    def iter_paths(self):
-        """!Iterates over paths to files that must be generated."""
-        for path in self.__files.keys():
-            yield path
-    def iter_testnames(self):
-        """!Iterates over names of tests."""
-        for taskname in self.__tasklist:
-            yield taskname
-    def iter_files(self):
-        """!Iterates over files to be generated, yielding tuples
-        containing the path and contents."""
-        for path,contents in self.__files.items():
-            yield path,contents
-    def iter_tests(self):
-        """!Iterates over all RocotoTasks for tests to run, yielding a
-        tuple containing the test name and RocotoTask."""
-        for taskname in self.__tasklist:
-            yield taskname,self.__taskdict[taskname]
-    def as_walltime(self,time,con):
-        """!Resolves the given numeric variable and turns it into a
-        Rocoto-style wallclock time.
-
-        @param time the variable reference
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables."""
-        time=to_rocoto_walltime(self.getvar(time).numeric_context(con))
-        assert(time is not None)
-        return time
-    def install_dir(self,con):
-        """!Returns the directory in which to install the generated workflow.
-
-        Gets the installation area for the created workflow from
-        "plat%rocoto%install_dir", expressed in a string context.
-        This is the top-level installation directory; the parent of
-        ush/, jobs/, etc.
-
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @return the directory in which to install the workflow"""
-        idir=self.getvar('plat%rocoto%install_dir').string_context(con)
-        assert(idir.find('@')<0)
-        return idir
-    def make_prep_baseline_sh(self,con):
-        """!Creates a script that prepares the baseline when run in
-        baseline generation mode.
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @returns the resulting script as a string"""
-        baseline=self.getvar('plat%BASELINE').bash_context(con)
-        template=self.getvar('plat%BASELINE_TEMPLATE').bash_context(con)
-        return r'''#! /bin/sh
-
-set -xue
-
-baseline=%s
-template=%s
-mkdir -p "$baseline"
-cd "$baseline"
-rsync -arv "$template"/. .
-'''%(baseline,template)
-
-    def generate_xml(self,out,con):
-        """!Generates the Rocoto workflow document.
-
-        Writes the contents of the Rocoto XML document to the given
-        file-like stream.
-
-        @param out a file-like stream to which the document will be written.
-        @param con a produtil.testing.parsetree.Context to use when
-        resolving variables.
-        @returns None"""
-        default_task_throttle=produtil.testing.parsetree.String([],'55',False)
-        one_max_try=produtil.testing.parsetree.String([],'1',False)
-        try:
-            walltime=self.as_walltime('walltime',con)
-        except KeyError as ke:
-            walltime=self.as_walltime('plat%BUILD_WALLTIME',con)
-        kwargs={
-            'account':self.as_attr('plat%CPU_ACCOUNT',con),
-            'log_dir':self.as_attr('plat%rocoto%log_dir',con),
-            'install_dir':self.as_attr('plat%rocoto%install_dir',con),
-            'UNIQUE_ID':self.as_attr('UNIQUE_ID',con),
-            'scheduler':self.as_attr('plat%rocoto%scheduler',con),
-            'name':self.name,
-            'cycle':'202012311830',
-            'build_resources':self.getvar('plat%rocoto%build_resources').string_context(con),
-            'build_walltime':walltime,
-            'entities':self.getvar('plat%rocoto%entities').string_context(con),
-            'baseline':self.getvar('plat%BASELINE').string_context(con),
-            'template':self.getvar('plat%BASELINE_TEMPLATE').string_context(con),
-            'build_deps':'',
-            'build_maxtries':self.getvar('plat%BUILD_MAX_TRIES',one_max_try).string_context(con),
-            'test_maxtries':self.getvar('plat%TEST_MAX_TRIES',one_max_try).string_context(con),
-            'task_throttle':self.getvar('plat%TASK_THROTTLE',default_task_throttle) \
-                           .string_context(con)
-            }
-        if self.mode is BASELINE:
-            kwargs['build_deps']=r'''      <dependency>
-        <taskdep task="prep_baseline"/>
-      </dependency>'''
-        out.write(r'''<?xml version="1.0"?>
-<!DOCTYPE workflow
-[
-  <!ENTITY WORKFLOW_NAME "{name:s}">
-  <!ENTITY LOG_DIR "{log_dir:s}">
-  <!ENTITY INSTALL_DIR "{install_dir:s}">
-  <!ENTITY ACCOUNT "{account:s}">
-  <!ENTITY UNIQUE_ID "{UNIQUE_ID:s}">
-  <!ENTITY BUILD_MAXTRIES "{build_maxtries}">
-  <!ENTITY TEST_MAXTRIES "{test_maxtries}">
-  <!ENTITY TASK_THROTTLE "{task_throttle}">
-{entities:s}
-]>
-
-<!-- Workflow begins here -->
-
-<!-- BASELINE = {baseline} -->
-<!-- TEMPLATE = {template} -->
-
-<workflow realtime="F" cyclethrottle="1"
-          scheduler="{scheduler:s}"
-          taskthrottle="&TASK_THROTTLE;">
-
-  <!-- Rocoto is cycle-based, so we have to specify a cycle to run.
-       This does NOT set the cycle to run in each regression test; it
-       is only for Rocoto bookkeeping purposes. -->
-  <cycledef>{cycle:s} {cycle:s} 01:00:00</cycledef>
-
-  <!-- Tell Rocoto where to put Rocoto-specific log messages. -->
-  <log><cyclestr>&LOG_DIR;/rocoto_@Y@m@d@H.log</cyclestr></log>
-
-'''.format(**kwargs))
-
-        if self.mode is BASELINE:
-            out.write(r'''  <!-- Special task to copy baseline template -->
-    <task name="prep_baseline" maxtries="&BUILD_MAXTRIES;">
-      <command>sh -c 'cd &INSTALL_DIR; ; ./ush/prep_baseline.sh'</command>
-      <jobname>prep_baseline</jobname>
-      <account>&ACCOUNT;</account>
-      <walltime>{build_walltime}</walltime>
-      {build_resources:s}
-      <envar>
-        <name>RT_INSTALL_DIR</name>
-        <value>&INSTALL_DIR;</value>
-      </envar>
-      <join>&LOG_DIR;/prep_baseline.log</join>
-    </task>
-
-'''.format(**kwargs))
-
-        if self.has_builds():
-            out.write(r'''  <!-- Build system definitions begin here -->
-  <metatask name="builds" mode="serial">
-    <var name="BUILD">'''.format(**kwargs))
-            out.write(' '.join([ b for b in self.iter_buildnames()]))
-            out.write(r'''</var>
-    <task name="build_#BUILD#" maxtries="&BUILD_MAXTRIES;">
-      <command>sh -c 'cd &INSTALL_DIR;/src ; ./install.sh #BUILD#'</command>
-      <jobname>rt_build_#BUILD#</jobname>
-      <account>&ACCOUNT;</account>
-      <walltime>{build_walltime}</walltime>
-      {build_resources:s}
-      <envar>
-        <name>RT_INSTALL_DIR</name>
-        <value>&INSTALL_DIR;</value>
-      </envar>
-      <join>&LOG_DIR;/build_#BUILD#.log</join>
-{build_deps:s}
-      <rewind>
-        <sh>set -xue ; cd "&INSTALL_DIR;/src" ; ./uninstall.sh "#BUILD#"</sh>
-      </rewind>
-    </task>
-  </metatask>
-
-'''.format(**kwargs))
-
-        out.write('  <!-- Test definitions begin here. -->\n\n'.format(**kwargs))
-
-        for testname,test in self.iter_tests():
-            test.generate_xml(out,self,con)
-
-        out.write(r'''
-  <!-- End of test definitions. -->
-
-''')
-
-
-        out.write(r'''</workflow>
-
-<!-- End of Rocoto workflow document -->
-''')
-
-########################################################################
-
-def get_name(runcon):
-    """!Gets the name of the test or build.
-
-    @param runcon a produtil.testing.parse.RunConPair containing a
-    build (produtil.testing.parsetree.Build) or test to run
-    (produtil.testing.parsetree.Test).
-    @returns the name of the build or test as a string"""
-    try:
-        return runcon.runnable.resolve('TEST_NAME').string_context(runcon.context)
-    except KeyError as ke:
-        return runcon.runnable.resolve('BUILD_NAME').string_context(runcon.context)
-
-class RocotoRunner(object):
-    """!Generates a three-tier NCEP EE2 structure to run a test suite
-    in Rocoto."""
-    def __init__(self):
-        """!Constructor for RocotoRunner.
-
-        Initializes the object so that make_runner() will be able to
-        function properly.  Presently, this function does nothing."""
-        super(RocotoRunner,self).__init__()
-    def make_runner(self,parser,dry_run=False,setarith=None):
-        """!Creates a Rocoto workflow for the given arguments.
-
-        @param parser The produtil.testing.parse.Parser containing all
-        needed information.  This is used to get the list of runnable
-        tasks and builds, the sets of tasks and builds, and all
-        configuration information.
-
-        @param dry_run If True, the make_runner only logs what is to
-        be done without actually doing it.
-
-        @param setarith Optional: a string recognized by
-        produtil.testing.setarith.arithparse().  This is used to
-        generate the list of Tasks and Builds to run.  If no setarith
-        is given, all Tests and Builds with "run" blocks are run."""
-        dry_run=bool(dry_run)
-        work=None
-        con=None
-        runset=parser.setarith(setarith)
-        logger=parser.logger
-        mode=parser.run_mode
-        for runcon in runset:
-            runme,raw_con=runcon.as_tuple
-            runme_context=produtil.testing.script.runner_context_for(raw_con)
-            if work is None:
-                work=RocotoWorkflow('rt',runme.defscopes[-1],mode)
-            work.run(runme,runme_context)
-            if con is None:
-                con=runme_context
-
-        if work is None:
-            raise ValueError('ERROR: No "run" statments seen; '
-                             'nothing to do.\n');
-        assert(con is not None)
-
-        def here(path):
-            here=os.path.normpath(os.path.join(work.install_dir(con),path))
-            dir=os.path.normpath(os.path.dirname(here))
-            if dir!=here and not dry_run and not os.path.isdir(dir):
-                logger.info('%s: make directory'%(dir,))
-                produtil.fileop.makedirs(dir)
-            logger.info('%s: write file'%(here,))
-            return here
-
-        target=here('rocoto/workflow.xml')
-        if not dry_run:
-            with open(target,'wt') as f:
-                work.generate_xml(f,con)
-        target=here('src/install.sh')
-        if not dry_run:
-            with open(target,'wt') as f:
-                f.write(work.generate_install_script())
-                os.fchmod(f.fileno(),0o755)
-        target=here('src/uninstall.sh')
-        if not dry_run:
-            with open(target,'wt') as f:
-                f.write(work.generate_uninstall_script())
-                os.fchmod(f.fileno(),0o755)
-        if mode is BASELINE:
-            target=here('ush/prep_baseline.sh')
-            if not dry_run:
-                with open(target,'wt') as f:
-                    f.write(work.make_prep_baseline_sh(con))
-                    os.fchmod(f.fileno(),0o755)
-        for name,test in work.iter_tests():
-            target=here(test.j_job_name(work,con))
-            if not dry_run:
-                with open(target,'wt') as f:
-                    f.write(test.j_job_contents(work,con))
-                    os.fchmod(f.fileno(),0o755)
-            target=here(test.ex_script_name(work,con))
-            if not dry_run:
-                with open(target,'wt') as f:
-                    f.write(test.ex_script_contents(work,con))
-                    os.fchmod(f.fileno(),0o755)
-        target=here('ush/functions.bash')
-        if not dry_run:
-            with open(target,'wt') as f:
-                f.write('# DO NOT EDIT THIS SCRIPT; '
-                        'IT IS AUTOMATICALLY GENERATED\n')
-                f.write('# These are bash functions used '
-                        'by the ex-scripts.\n\n')
-                f.write(bash_functions)
diff --git a/produtil/testing/script.py b/produtil/testing/script.py
deleted file mode 100644
index 5c61add4e1..0000000000
--- a/produtil/testing/script.py
+++ /dev/null
@@ -1,374 +0,0 @@
-"""!Takes an object tree from produtil.parse.Parser and turns it into
-a flat bash script that will run the entire test suite, one test at a
-time."""
-
-import io
- 
-__all__=['bash_functions','BashRunner']
-
-import produtil.testing.parsetree
-from produtil.testing.utilities import PTParserError
-
-##@var bash_functions
-# Utility functions for bash scripts.
-
-bash_functions=r'''
-function report_start() {
-  local parent
-  parent=$( dirname "$1" )
-  for x in 1 2 3 4 5 6 7 8 9 0 ; do
-    if [[ ! -d "$parent" ]] ; then
-      mkdir -p "$parent" || true
-    fi
-  done
-  rt__TEST_REPORT_FILE="$1"
-  rt__TEST_SUCCESS="YES"
-  shift 1
-  echo "$*" > "$rt__TEST_REPORT_FILE"
-  date >> "$rt__TEST_REPORT_FILE"
-}
-
-function report_line() {
-  echo "$*" >> "$rt__TEST_REPORT_FILE"
-}
-
-function report_stdin() {
-  cat >> "$rt__TEST_REPORT_FILE"
-}
-
-function report_failure() {
-  echo "$*" >> "$rt__TEST_REPORT_FILE"
-  rt__TEST_SUCCESS=NO
-}
-
-function report_finish() {
-  if [[ "$rt__TEST_SUCCESS" == "YES" ]] ; then
-    echo "TEST PASSED AT $( date )" >> "$rt__TEST_REPORT_FILE"
-  else
-    echo "TEST FAILED AT $( date )" >> "$rt__TEST_REPORT_FILE"
-    exit 1
-  fi
-}
-
-function deliver_file() {
-  local src tgt parent
-  set -e
-  src="$1"
-  tgt="$2"
-  if [[ -d "$src" ]] ; then
-    tgt=$( echo "$tgt" | sed 's,/*$,,g' )
-    rm -rf "$tgt"
-    cp -rp "$src" "$tgt"
-  else
-    # If the tgt is a directory, place the source within.
-    # If the tgt does not exist, but appears to be the name of a
-    # directory, make that directory and place the source within.
-    #    /path/to/dirname/  <-- ends with /
-    #    /path/to/place/.   <-- . is always a directory
-    #    /path/to/place/..  <-- .. is always a directory
-    if [[  -d "$tgt"                               || \
-         ! -e "$tgt" && "${tgt: -1}" == /          || \
-         ! -e "$tgt" && "$( basename $tgt )" == .  || \
-         ! -e "$tgt" && "$( basename $tgt )" == .. ]] ; then
-      tgt="$tgt"/$( basename "$src" )
-    fi
-    parent=$( dirname "$tgt" )
-    if [[ ! -d "$parent" ]] ; then
-      mkdir -p "$parent"
-    fi
-    tmpfile="$tgt.$$.$RANDOM.$RANDOM"
-    cp -fp "$src" "$tmpfile"
-    mv -fT "$tmpfile" "$tgt"
-  fi
-}
-function comparison_wrapper() {
-  local src tgt bn result origtgt
-  set -e
-  set +x
-  cmd="$1"
-  message="$2"
-  src="$3"
-  tgt="$4"
-  if [[ -d "$tgt" ]] ; then
-    bn=$( basename "$src" )
-    tgt="$tgt/$bn"
-  elif [[ -d "$src" ]] ; then
-    bn=$( basename "$tgt" )
-    src="$src/$bn"
-  fi
-  echo TARGET: $( md5sum $tgt )
-  ls -l $tgt
-  echo SOURCE: $( md5sum $src )
-  ls -l $src
-  set +e
-  if [[ ! -e "$src" ]] ; then
-    report_failure "$tgt: MISSING BASELINE FILE"
-    return 1
-  elif [[ ! -e "$tgt" ]] ; then
-    report_failure "$src: MISSING OUTPUT FILE"
-    return 1
-  fi
-  set -x
-  $cmd "$src" "$tgt"
-  result=$?
-  if [[ "$result" != 0 ]] ; then
-    report_failure "$src: $message MISMATCH"
-  else
-    report_line "$src: $message identical"
-  fi
-  return $result
-}
-
-function bitcmp() {
-  comparison_wrapper cmp "bit-for-bit" "$1" "$2"
-  result=$?
-  return $result
-}
-
-function nccmp_vars() {
-  comparison_wrapper "nccmp -d" "NetCDF variable data" "$1" "$2"
-  result=$?
-  return $result
-}
-
-function atparse {
-    set +x # There is too much output if "set -x" is on.
-    set +u # We expect empty variables in this function.
-    set +e # We expect some evals to fail too.
-    # Use __ in names to avoid clashing with variables in {var} blocks.
-    local __text __before __after __during
-    for __text in "$@" ; do
-        if [[ $__text =~ ^([a-zA-Z][a-zA-Z0-9_]*)=(.*)$ ]] ; then
-            eval "local ${BASH_REMATCH[1]}"
-            eval "${BASH_REMATCH[1]}="'"${BASH_REMATCH[2]}"'
-        else
-            echo "ERROR: Ignoring invalid argument $__text\n" 1>&2
-        fi
-    done
-    while IFS= read -r __text ; do
-        while [[ "$__text" =~ ^([^@]*)(@\[[a-zA-Z_][a-zA-Z_0-9]*\]|@\[\'[^\']*\'\]|@\[@\]|@)(.*) ]] ; do
-            __before="${BASH_REMATCH[1]}"
-            __during="${BASH_REMATCH[2]}"
-            __after="${BASH_REMATCH[3]}"
-#            printf 'PARSE[%s|%s|%s]\n' "$__before" "$__during" "$__after"
-            printf %s "$__before"
-            if [[ "$__during" =~ ^@\[\'(.*)\'\]$ ]] ; then
-                printf %s "${BASH_REMATCH[1]}"
-            elif [[ "$__during" == '@[@]' ]] ; then
-                printf @
-            elif [[ "$__during" =~ ^@\[([a-zA-Z_][a-zA-Z_0-9]*)\] ]] ; then
-                set -u
-                eval 'printf %s "$'"${BASH_REMATCH[1]}"'"'
-                set +u
-            else
-                printf '%s' "$__during"
-            fi
-            if [[ "$__after" == "$__text" ]] ; then
-                break
-            fi
-            __text="$__after"
-        done
-        printf '%s\n' "$__text"
-    done
-}
-'''
-
-class ProdutilRunner(produtil.testing.parsetree.Context):
-    """!Uses produtil.run to generate an mpirun command from a
-    produtil.testing.parsetree.SpawnProcess object"""
-    def __init__(self,scopes,token,run_mode,logger,MPI,nodesize):
-        """!Constructor
-
-        @param scopes a list of nested scopes to search when resolving
-        variable references (outermost first)
-        @param token The token indicating the relevant file and line number
-        @param run_mode produtil.testing.utilities.EXECUTION to
-            execute and verify results, or
-            produtil.testing.utilities.BASELINE to generate a new
-            baseline.
-        @param logger a logging.Logger for logging messages"""
-        super(ProdutilRunner,self).__init__(
-            scopes,token,run_mode,logger)
-        MPI=MPI.lower()
-        
-        # Convert from common synonyms:
-        if MPI=='lsf':      MPI='mpirun_lsf'
-        if MPI=='lsfcray':  MPI='lsf_cray_intel'   # alias for Rocoto lsfcray
-        if MPI=='mpich':    MPI='impi'
-        if MPI=='lsf_impi': MPI='impi'
-        if MPI=='mvapich2': MPI='mpiexec'
-        if MPI=='moab':     MPI='moab_cray'        # alias for Rocoto moab
-
-        self.mpiimpl=produtil.run.make_mpi(
-            MPI,total_tasks=nodesize,nodesize=nodesize,force=True,silent=True)
-    def mpirunner(self,spawnProcess,distribution):
-        """!Generates the mpi launching command for the given
-        produtil.testing.parsetree.SpawnProcess object
-
-        @param spawnProcess a description of the process to execute
-        @returns a string containing the mpirun command"""
-        cmd=None
-        is_mpi=False
-        mpiimpl=self.mpiimpl
-        for rank in spawnProcess.iterrank():
-
-            ranks=rank.ranks(self)
-            ppn=rank.ppn(self)
-            threads=rank.threads(self)
-
-            if cmd is not None and not ranks:
-                raise PTParserError('Error: mixing MPI and non-MPI programs in the same command is not supported.')
-        
-            args=[ arg.string_context(self) for arg in rank.args ]
-
-            if ranks:
-                cmdpart=produtil.run.mpi(args[0])
-                cmdpart=cmdpart[args[1:]]
-                is_mpi=True
-            else:
-                cmdpart=produtil.run.exe(args[0],mpiimpl=mpiimpl)
-                cmdpart=cmdpart[args[1:]]
-
-            if ranks and ppn:
-                cmdpart=cmdpart.rpn(ppn)
-            
-            if threads:
-                cmdpart=produtil.run.openmp(cmdpart,threads=threads,mpiimpl=mpiimpl)
-
-            if ranks:
-                cmdpart=cmdpart*ranks
-
-            if cmd is None:
-                cmd=cmdpart
-            else:
-                cmd=cmd+cmdpart
-
-        if is_mpi:
-            cmd=produtil.run.mpirun(cmd,mpiimpl=mpiimpl,label_io=True,scheduler_distribution=distribution)
-        return cmd.to_shell()
-
-class MPICHRunner(produtil.testing.parsetree.Context):
-    """!Generates an mpirun command for running in MPICH, from a
-    produtil.testing.parsetree.SpawnProcess object"""
-    def __init__(self,scopes,token,run_mode,logger):
-        """!Constructor
-
-        @param scopes a list of nested scopes to search when resolving
-        variable references (outermost first)
-        @param token The token indicating the relevant file and line number
-        @param run_mode produtil.testing.utilities.EXECUTION to
-            execute and verify results, or
-            produtil.testing.utilities.BASELINE to generate a new
-            baseline.
-        @param logger a logging.Logger for logging messages"""
-        super(MPICHRunner,self).__init__(
-            scopes,token,run_mode,logger)
-    def mpirunner(self,spawnProcess,distribution):
-        """!Generates the mpirun command for the given
-        produtil.testing.parsetree.SpawnProcess object
-
-        @param spawnProcess a description of the process to execute
-        @returns a string containing the mpirun command"""
-        out=io.StringIO()
-        out.write('mpirun')
-        for rank in spawnProcess.iterrank():
-            out.write(' -np %d %s'%(
-                    rank.ranks(self),
-                    ' '.join([r.bash_context(self)
-                              for r in rank.args])))
-        ret=out.getvalue()
-        out.close()
-        return ret
-
-class LSFRunner(produtil.testing.parsetree.Context):
-    """!Generates an mpirun.lsf command for running within IBMPE and
-    LSF, from a produtil.testing.parsetree.SpawnProcess object"""
-    def __init__(self,scopes,token,run_mode,logger):
-        """!Constructor
-
-        @param scopes a list of nested scopes to search when resolving
-        variable references (outermost first)
-        @param token The token indicating the relevant file and line number
-        @param run_mode produtil.testing.utilities.EXECUTION to
-            execute and verify results, or
-            produtil.testing.utilities.BASELINE to generate a new
-            baseline.
-        @param logger a logging.Logger for logging messages"""
-        super(LSFRunner,self).__init__(
-            scopes,token,run_mode,logger)
-    def mpirunner(self,spawnProcess,distribution):
-        """!Generates the mpirun.lsf command for the given
-        produtil.testing.parsetree.SpawnProcess object
-
-        @param spawnProcess a description of the process to execute
-        @returns a string containing the mpirun.lsf command"""
-        prior=None
-        for rank in spawnProcess.iterrank():
-            prog=' '.join([r.bash_context(self)
-                           for r in rank.args])
-            if prior is not None and prior!=prog:
-                raise NotImplementedError(self.error(
-                        'MPMD is not yet supported for LSF.'))
-        return 'mpirun.lsf '+prog
-
-def runner_context_for(con):
-    """!Returns a context with an mpirunner(spawnProcess,distribution) function,
-    such as the LSFRunner or MPICHRunner classes.
-
-    @param con the context to use when resolving "plat%MPI" to get the
-    requested MPI implementation.
-
-    @returns A Context whose mpirunner() function can create MPI
-    program launcher commands. """
-    MPI=con.scopes[-1].resolve('plat%MPI').string_context(con)
-    nodesize=con.scopes[-1].resolve('plat%cores_per_node').numeric_context(con)
-    return ProdutilRunner(con.scopes,con.token,con.run_mode,con.logger,MPI,nodesize)
-
-class BashRunner(object):
-    """!Generates self-contained bash scripts that can run an entire test suite."""
-    def __init__(self):
-        """!Constructor for RocotoRunner.
-
-        Initializes the object so that make_runner() will be able to
-        function properly.  Presently, this function does nothing."""
-        super(BashRunner,self).__init__()
-    def make_runner(self,parser,output_file,dry_run=False,
-                    setarith=None):
-        """!Creates a bash script for the given arguments.
-
-        @param parser The produtil.testing.parse.Parser containing all
-        needed information.  This is used to get the list of runnable
-        tasks and builds, the sets of tasks and builds, and all
-        configuration information.
-
-        @param output_file The name of the file to write.  This file
-        will contain the bash script.
-
-        @param dry_run If True, the make_runner only logs what is to
-        be done without actually doing it.
-
-        @param setarith Optional: a string recognized by
-        produtil.testing.setarith.arithparse().  This is used to
-        generate the list of Tasks and Builds to run.  If no setarith
-        is given, all Tests and Builds with "run" blocks are run."""
-        logger=parser.logger
-        runset=parser.setarith(setarith)
-        logger.info('%s: generate bash script'%(output_file,))
-        if dry_run: return
-        with open(output_file,'wt') as out:
-            out.write(r'''#! /usr/bin/env bash
-
-%s
-
-set -xe
-
-'''%(bash_functions,))
-
-            seen=False
-            for runcon in runset:
-                runme,con=runcon.as_tuple
-                seen=True
-                out.write(runme.bash_context(runner_context_for(con)))
-                out.write("\n\n")
-        if not seen:
-            raise ValueError('ERROR: No "run" statments seen; nothing to do.\n');
diff --git a/produtil/testing/setarith.py b/produtil/testing/setarith.py
deleted file mode 100644
index 433634a3f2..0000000000
--- a/produtil/testing/setarith.py
+++ /dev/null
@@ -1,290 +0,0 @@
-"""!Set arithmetic logic utilities.  This implements a simple set
-logic language, and uses it to combine Python sets.  It operates on
-produtil.testing.utilities.ListableSet objects.  The main entry point,
-arithparse(), returns a result of the same type.
-
-Examples:
-
-@code
-elements=ListableSet(["cat","dog","orange","salmon","bin"])
-sets={ "alive":    ListableSet(["cat","dog","orange","salmon"]),
-       "colors":   ListableSet(["orange","salmon"]),
-       "commands": ListableSet(["cat","bin"]),
-       "verbs":    ListableSet(["cat","dog","bin"])
-       }
-
-# Request a single set:
-arithparse("alive",sets,elements)
-#  --> ListableSet(["cat","dog","orange","salmon"])
-
-# Subtraction of two sets:
-arithparse("minus(alive,colors)",sets,elements)
-#  --> ListableSet(["cat","dog"])
-
-# Union of two sets:
-arithparse("union(colors,commands)",sets,elements)
-#  --> ListableSet(["orange","salmon","cat","bin"])
-
-# Intersection of two sets:
-arithparse("inter(alive,verbs)",sets,elements)
-#  --> ListableSet(["cat","dog"])
-
-# Individual elements:
-arithparse("{cat,orange}")
-#  --> ListableSet(["cat","orange"])
-
-# Combination of the above:
-arithparse("minus(inter(union({dog,orange},commands),alive),verbs)")
-#  --> ListableSet(["dog"])
-@endcode
-
-"""
-
-import os, re
-
-from produtil.testing.utilities import peekable, ListableSet, PTParserError
-
-__all__=[ 'ArithPTParserError', 'arithparse', 'ArithKeyError' ]
-
-def arithparse(spec,sets,elements):
-    """!Main entry point to the setarith module.
-
-    Performs the specified set arithmetic on the given elements and
-    sets, returning the resulting set.
-
-    @param spec A setarith language expression describing the operation.
-
-    @param sets A mapping from set name to
-    produtil.testing.utilities.ListableSet objects that represent each
-    set.
-
-    @param elements All known elements.  This is a superset of all
-    other sets, and may contain additional elements.
-"""
-    assert(isinstance(spec,str))
-    tokiter=peekable(_arithtoken(spec))
-    result=_arithparse_top(tokiter,sets,elements)
-    return result
-
-class ArithException(PTParserError):
-    """!Raised for parser errors in the inputs to the set arithmetic
-    parser (arithparse)."""
-
-class ArithKeyError(ArithException,KeyError):
-    """!Raised when an element or set is requested that does not exist"""
-
-########################################################################
-
-def _arithtoken(spec):
-    """!Tokenizes a set arithmetic expression.
-    @protected
-    @see arithparse()"""
-    assert(isinstance(spec,str))
-    for m in re.finditer(r'''(?xs)
-        (
-            (?P<oper>[A-Za-z]+) \(
-          | (?P<endoper> \) )
-          | (?P<setname> [A-Za-z][A-Za-z%._0-9]* )
-          | (?P<comma> , )
-          | (?P<lset> \{ )
-          | (?P<rset> \} )
-          | (?P<whitespace>\s+)
-          | (?P<star>\*)
-          | (?P<error> . )
-        )''',spec):
-        if m.group('whitespace'):
-            continue # ignore whitespace
-        elif m.group('oper'):
-            yield 'oper',m.group('oper')
-        elif m.group('endoper'):
-            yield ')',m.group('endoper')
-        elif m.group('setname'):
-            yield 'set',m.group('setname')
-        elif m.group('comma'):
-            yield ',',','
-        elif m.group('lset'):
-            yield '{','{'
-        elif m.group('rset'):
-            yield '}','}'
-        elif m.group('star'):
-            yield '*','*'
-        elif m.group('error'):
-            raise ArithException('Unexpected character %s'%(
-                    repr(m.group('error')),))
-    yield '',''
-
-########################################################################
-
-def each_not_all(sets):
-    """!Iterates over the given ListableSet, yielding everything
-    except the special set "*" """
-    for s in sets.keys():
-        if s[0]!='*':
-            yield s
-
-# Internal implementation routines
-
-def _arithparse_set(tokiter,elements):
-    """!Parses an explicit set definition
-
-    Parses a list of elements:
-
-    @code
-      {element1,element2,element3}
-    @endcode
-
-    @param tokiter a peekable iterator that yields tokens
-    @param elements All known elements.  This is a superset of all
-    other sets, and may contain additional elements.
-
-    @returns a new ListableSet
-    @protected
-    """
-    typ,data=tokiter.peek()
-    result=ListableSet()
-    while typ=='set':
-        if data in elements:
-            result.add(elements[data])
-        else:
-            raise ArithKeyError(
-                'Unknown test %s. Please select one of: { %s }'%(
-                    repr(data), ', '.join([
-                            str(k) for k in elements.keys()])))
-        next(tokiter) # discard element name
-        typ,data=tokiter.peek()
-        if typ==',':
-            typ,data=next(tokiter) # discard comma and then
-            typ,data=tokiter.peek() # peek next token
-    if not typ:
-        raise ArithException(
-            'Unexpected end of text when parsing an '
-            'argument list to an operator.')
-    if typ!='}':
-        raise ArithException(
-            'Unexpected %s when parsing an set {} definition '%(repr(data),))
-    else:
-        next(tokiter)
-    return result
-
-def _arithparse_list(tokiter,sets,elements):
-    """!Iterates over the arguments to a set arithmetic function,
-    yielding sets.  Calls _arithparse_expr() on each argument.
-
-    @param elements All known elements.  This is a superset of all
-    other sets, and may contain additional elements.
-
-    @param sets A mapping from set name to
-    produtil.testing.utilities.ListableSet objects that represent each
-    set.
-
-    @protected
-    @see arithparse()
-    @returns Nothing; this is an iterator."""
-    yielded=False
-    typ,data=tokiter.peek()
-    while typ in ['oper','set','{','*']:
-        result=_arithparse_expr(tokiter,sets,elements)
-        assert(isinstance(result,ListableSet))
-        yield result
-        yielded=True
-        typ,data=tokiter.peek()
-        if typ==',':
-            typ,data=next(tokiter) # discard comma and then
-            typ,data=tokiter.peek() # peek next token
-    if not typ:
-        raise ArithException(
-            'Unexpected end of text when parsing an '
-            'argument list to an operator.')
-    if typ!=')':
-        raise ArithException(
-            'Unexpected %s when parsing an argument '
-            'list to an operator.'%(repr(data),))
-    else:
-        typ,data=next(tokiter) # discard )
-
-def _arithparse_expr(tokiter,sets,elements):
-    """!Evaluates one set arithmetic expression.
-
-    Parses any expression with balanced parentheses.  That can be
-    anything from the entire string to a single set name.
-
-    @protected
-
-    @param tokiter a produtil.testing.utilities.peekable object that
-    iterates over the expression.
-    @param sets A mapping from set name to
-    produtil.testing.utilities.ListableSet objects that represent each
-    set.
-    @param elements All known elements.  This is a superset of all
-    other sets, and may contain additional elements.
-    @returns the resulting ListableSet"""
-
-    result='invalid value that should be replaced by below code'
-    typ,data=next(tokiter)
-    if typ=='oper':
-        if data=='union':
-            # Union of no sets is the empty set:
-            result=None
-            for subset in _arithparse_list(tokiter,sets,elements):
-                if result is None:
-                    result=subset
-                else:
-                    result.union(subset)
-            if result is None:
-                result=ListableSet()
-        elif data=='inter':
-            result=None
-            for subset in _arithparse_list(tokiter,sets,elements):
-                if result is None:
-                    result=subset
-                else:
-                    result.inter(subset)
-            if result is None:
-                # Intersection of no sets is the empty set:
-                result=ListableSet()
-        elif data=='minus':
-            result=None
-            for subset in _arithparse_list(tokiter,sets,elements):
-                if result is None:
-                    result=subset
-                else:
-                    result.minus(subset)
-        else:
-            raise ArithException('Invalid operator %s.  Should be union, '
-                            'inter, or minus.'%(data,))
-    elif typ=='set':
-        if data not in sets:
-            raise ArithKeyError('Unknown runset %s.  Known sets: { %s }'%(
-                    repr(data), ', '.join([
-                            str(k) for k in each_not_all(sets)])))
-        result=ListableSet(sets[data])
-    elif typ=='*':
-        result=ListableSet([val for key,val in elements.items()])
-    elif typ=='{':
-        result=_arithparse_set(tokiter,elements)
-    else:
-        raise ArithException('Unexpected %s in set spec.'%(repr(data),))
-    assert(isinstance(result,ListableSet))
-    return result
-
-def _arithparse_top(tokiter,sets,elements):
-    """!Evaluates the null string, or one set arithmetic expression.
-
-    When given the null string, this immediately returns an empty
-    ListableSet.  Otherwise, it passes control to _arithparse_expr()
-    to parse the resulting expression.
-
-    @protected
-
-    @param tokiter a produtil.testing.utilities.peekable object that
-    iterates over the expression.
-    @param sets A mapping from set name to
-    produtil.testing.utilities.ListableSet objects that represent each
-    set.
-    @param elements All known elements.  This is a superset of all
-    other sets, and may contain additional elements.
-    @returns the resulting ListableSet"""
-    typ,data = tokiter.peek()
-    if not typ:
-        return ListableSet()
-    return _arithparse_expr(tokiter,sets,elements)
diff --git a/produtil/testing/testgen.py b/produtil/testing/testgen.py
deleted file mode 100644
index 44fc612cdf..0000000000
--- a/produtil/testing/testgen.py
+++ /dev/null
@@ -1,171 +0,0 @@
-"""!Utility package for making programs that are wrapped around the
-produtil.testing package."""
-
-import os, logging
-
-import produtil.fileop
-
-from produtil.testing.utilities import BASELINE, EXECUTION
-from produtil.testing.tokenize import Tokenizer, TokenizeFile
-from produtil.testing.parse import Parser
-from produtil.testing.rocoto import RocotoRunner
-from produtil.testing.script import BashRunner
-from produtil.testing.parsetree import fileless_context
-from produtil.testing.setarith import arithparse
-
-__all__=[ 'TestGen' ]
-
-class TestGen(object):
-    """!"""
-    def __init__(self, run_mode, OutputType, outloc, inloc, dry_run, 
-                 unique_id, logger=None, verbose=True, PWD=None,
-                 setarith=None, platform_name=None):
-        """!Constructor for TestGen
-
-        @param run_mode Run mode: baseline or execution.  Must be
-        produtil.testing.utilities.BASELINE or
-        produtil.testing.utilities.EXECUTION
-
-        @param OutputType the class that generates the workflow script
-        or scripts.  This should be
-        produtil.testing.rocoto.RocotoRunner or
-        produtil.testing.script.BashRunner
-
-        @param outloc The output directory or script filename for the workflow
-
-        @param inloc The input file to send to the parser and tokenizer
-
-        @param dry_run If True, then the test suite will not be
-        generated.  Instead, the functions will just log what they
-        would have done.
-
-        @param unique_id Optional.  Integer ID for the workflow.  By
-        default, Null is sent into the OutputType's constructor, to
-        indicate that it should choose one for you.
-
-        @param logger a logging.Logger to log messages
-
-        @param verbose If True, send verbose log messages.
-
-        @param PWD The directory to use for PWD in the script
-        generator.  The default is the top of the produtil package
-        installation area (parent of the testing/ directory.)
-
-        @param setarith Optional.  A produtil.testing.setarith style
-        set arithmetic expression to select which tests and builds to
-        run.  By default, all known tests are run."""
-        if PWD is None:
-            # Default PWD is produtil:
-            PWD=os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
-        if logger is None:
-            logger=logging.getLogger('testgen')
-        self.setarith=setarith
-        self.logger=logger
-        self.run_mode=run_mode
-        self.OutputType=OutputType
-        self.outloc=outloc
-        self.inloc=inloc
-        self.dry_run=dry_run
-        self.unique_id=unique_id
-        self.platform_name=platform_name
-        self.verbose=bool(verbose)
-        self.PWD=PWD
-        self.scope=None
-        self.parser=None
-        self.parse_result=None
-        assert(isinstance(self.unique_id,int))
-
-    def get_string(self,varname):
-        """!Resolves the given variable reference within the global scope
-
-        @param varname a variable reference, such as "plat%BASELINE"
-        to send to self.scope.resolve().  
-
-        @returns the string value of the varname
-
-        @raise KeyError if the variable does not exist"""
-        var=self.scope.resolve(varname)
-        con=fileless_context(verbose=self.verbose)
-        return var.string_context(con)
-
-    def make_vars(self):
-        """!Generates global scope constants for the parser's global scope.
-
-        Creates and returns a dict with global constants.
-
-        - OUTPUT_PATH: the target directory or file where the workflow
-          scripts or script should be placed
-
-        - PWD: the ush/ directory in which produtil is installed
-
-        - PWD_UP1, PWD_UP2, ...: 1, 2, etc. directories above PWD
-
-        @returns the dict with the constants"""
-        here=self.PWD
-        PWD_UP1=os.path.dirname(here)
-        PWD_UP2=os.path.dirname(PWD_UP1)
-        PWD_UP3=os.path.dirname(PWD_UP2)
-        PWD_UP4=os.path.dirname(PWD_UP3)
-        PWD_UP5=os.path.dirname(PWD_UP4)
-        return { 'PWD_UP1':PWD_UP1, 'PWD_UP2':PWD_UP2,
-                 'PWD_UP3':PWD_UP3, 'PWD_UP4':PWD_UP4,
-                 'PWD_UP5':PWD_UP5, 'OUTPUT_PATH':self.outloc,
-                 'PWD': here }
-    def make_more(self,result,con):
-        """!This routine is used by subclasses to make any additional
-        files from within testgen().  The default implementation does
-        nothing.
-
-        @param result the produtil.testing.parsetree.Scope for the
-        global scope of the parsed files
-
-        @param con the produtil.testing.parsetree.Context to use when
-        expanding strings or other objects from result."""
-    def override(self,scope):
-        """!Allows subclasses to override variables in the scope
-        before parsing.  The default implementation does nothing.
-
-        @param scope The global scope in which to override variables."""
-    def parse(self):
-        """!Parses the provided files and creates parser result variables.
-
-        Creates these variables by parsing the inloc
-
-        - scope: the produtil.testing.parsetree.Scope for the global scope
-
-        - parser: the produtil.testing.parsetree.Parser used to parse
-          the input files.
-
-        - parse_result: the return value from the Parser's parse
-          function (presently None)
-
-        @returns None"""
-        logger=self.logger
-        tokenizer=Tokenizer()
-        self.scope=produtil.testing.parsetree.Scope()
-        self.override(self.scope)
-        self.parser=Parser(self.run_mode,logger,self.verbose)
-        self.parser.requested_platform_name=self.platform_name
-        morevars=self.make_vars()
-        with open(self.inloc,'rt') as fileobj:
-            self.parse_result=self.parser.parse(
-                TokenizeFile(tokenizer,fileobj,self.inloc,1),self.scope,
-                unique_id=self.unique_id,morevars=morevars)
-    def generate(self):
-        """!Generates the on-disk files used to run the workflow."""
-        logger=self.logger
-        outputter=self.OutputType()
-        outputter.make_runner(parser=self.parser,dry_run=self.dry_run,
-                              setarith=self.setarith)
-        con=fileless_context(
-            scopes=[self.parse_result],verbose=self.verbose,logger=logger,
-            run_mode=self.run_mode)
-        self.make_more(self.parse_result,con)
-    def testgen(self):
-        """!Parses input files and generates the workflow scripts.
-
-        @see parse()
-        @see generate()"""
-        self.parse()
-        self.generate()
-            
diff --git a/produtil/testing/tokenize.py b/produtil/testing/tokenize.py
deleted file mode 100644
index 2311257c76..0000000000
--- a/produtil/testing/tokenize.py
+++ /dev/null
@@ -1,275 +0,0 @@
-"""!Tokenizer for the produtil.testing.parser module."""
-
-import re
-import produtil.testing.utilities
-
-__all__=[ 'Token', 'end_of_line_type', 'end_of_text_type', 'Tokenizer',
-          'TokenizeFile' ]
-
-class Token(object):
-    """!Represents one token in the tokenized version of a file."""
-
-    ##@var token_type
-    # The type of token, a string
-
-    ##@var token_value
-    # The text that was tokenized, a string.
-
-    ##@var filename
-    # The file from which this token originates, a string.  The
-    # special value produtil.testing.utilities.unknown_file indicates
-    # the file is unknown or the token is not from a file.
-
-    ##@var lineno
-    # The line from file filename fron which this token originates, an integer.
-    # The special value -1 means the line is unknown.
-
-    def __init__(self,token_type,token_value,filename,lineno):
-        """!Constructor for Token
-        
-        @param token_type The type of token, a string
-        @param token_value The text this token represents, a string.
-
-        @param filename The name of the file from which this token
-        originates or produtil.testing.utilities.unknown_file if
-        unknown.
-
-        @param lineno The integer line number, counting from 1, from
-        which this token originates.  Multi-line tokens should have a
-        line number representative of the region the token originates,
-        preferably on its first line.  If the token is not from a
-        file, the value should be -1."""
-        super(Token,self).__init__()
-        self.token_type=token_type
-        self.filename=filename
-        self.lineno=lineno
-        self.token_value=token_value
-    def __repr__(self):
-        """!A string representation of this token suitable for debugging.
-
-        @returns Python code that would construct this token."""
-        return 'Token(%s,%s,%s,%s)'%(
-            repr(self.token_type),repr(self.token_value),
-            repr(self.filename),repr(self.lineno))
-    def __str__(self):
-        """!A human-readable string representation of this token.
-
-        @returns Python code that would construct this token."""
-        return 'Token(%s,%s,%s,%s)'%(
-            repr(self.token_type),repr(self.token_value),
-            repr(self.filename),repr(self.lineno))
-
-##@var end_of_line_type
-# The token_type parameter to send to Token.__init__() to indicate the
-# end of a line
-end_of_line_type='\n'
-
-##@var end_of_text_type
-# The token_type parameter to send to Token.__init__() to indicate the
-# end of a file or string.
-end_of_text_type=''
-
-class Tokenizer(object):
-    """!Tokenizes a file, turning it into a stream of Token objects
-    for parsing."""
-
-    ##@var re
-    # A compiled regular expression used to tokenize the file.
-
-    def copy(self):
-        """!Duplicates this object
-        
-        At present, a Tokenizer has no internal state information.
-        Hence, this is equivalent to Tokenizer().  This may change in
-        the future.  Hence, if you want to copy a Tokenizer, you
-        should use the copy() function.
-
-        @returns A new empty Tokenizer."""
-        return Tokenizer()
-    def __init__(self):
-        """!Constructor for Tokenizer"""
-        super(Tokenizer,self).__init__()
-        #yell('compile\n')
-        self.re=re.compile(r'''(?xs)
-                (
-                    (?P<comment> \# [^\r\n]+ (?: \r | \n )+ )
-                  | (?P<commentend> \# [^\r\n]+ | \# ) $
-                  | (?P<varname> [A-Za-z_] [A-Za-z_0-9.@]*
-                       (?: % [A-Za-z_][A-Za-z_0-9.@]* )* )
-                  | (?P<hash>\#)
-                  | (?P<number>
-                        [+-]? [0-9]+\.[0-9]+ (?: [eE] [+-]? [0-9]+ )?
-                      | [+-]?       \.[0-9]+ (?: [eE] [+-]? [0-9]+ )?
-                      | [+-]? [0-9]+\.       (?: [eE] [+-]? [0-9]+ )?
-                      | [+-]? [0-9]+         (?: [eE] [+-]? [0-9]+ )?
-                    )
-                  | (?P<empty_qstring>  '' )
-                  | (?P<empty_dqstring> "" )
-                  | ' (?P<qstring> (?:
-                        [^'\\]
-                      | ( \\ . )+ ) * ) '
-                  | " (?P<dqstring> (?:
-                        [^"\\]
-                      | ( \\ . )+ ) * ) "
-                  | \[\[\[ (?P<bracestring> (?:
-                        [^\]@]
-                      | @ (?!\[)
-                      | @ \[ @ \]
-                      | @ \[ ' [^']+ ' \]
-                      | @ \[ [^\]]+ \]
-                      | \]\] (?!\])
-                      | \] (?!\])
-                    ) *? ) \]\]\]
-                  |   (?P<endline>[ \t]* [\r\n]+)
-                  |   (?P<equalequal> == )
-                  |   (?P<equal> = )
-                  |   (?P<astrisk> \* )
-                  |   (?P<whitespace> [ \t]+ )
-                  |   (?P<lset>\{)
-                  |   (?P<rset>\})
-                  |   (?P<lfort>\(/)
-                  |   (?P<rfort>/\))
-                  |   (?P<lparen>\()
-                  |   (?P<rparen>\))
-                  |   (?P<comma>,)
-                  |   (?P<colon>:)
-                  |   (?P<at>@)
-                  |   (?P<oper>\.[a-zA-Z_][a-zA-Z0-9_.]*\.)
-                  |   <=+ (?P<filter>[a-zA-Z_][a-zA-Z0-9_.]*) =+
-                  |   (?P<error> . )
-                )''')
-    def tokenize(self,text,filename=produtil.testing.utilities.unknown_file,
-                 first_line=1):
-        """!Tokenizes the specified file, acting as an iterator over Token objects.
-
-        Loops over the text of the given file, creating Token objects
-        and yielding them.  
-
-        @param text The text to tokenize.
-        @param filename The file from which the text originates.  This may be used
-          for two purposes.  The first is error reporting, and the second is 
-          "load" statements, which load files relative to the path to the 
-          current file.
-        @param first_line The line number for the first line of the file."""
-        lineno=first_line
-        for m in self.re.finditer(text):
-            if m is None: 
-                raise ValueError('SHOULD NOT GET HERE: no match on "%s"'%(line,))
-            # else:
-            #     for dkey,dval in m.groupdict().items():
-            #         if dval is not None:
-            #             yell("%10s = %s\n"%(dkey,repr(dval)))
-            if m.group('comment'):
-                yield Token(end_of_line_type,m.group('comment'),
-                            filename,lineno)
-            elif m.group('commentend'):
-                yield Token(end_of_line_type,m.group('commentend'),
-                            filename,lineno)
-            elif m.group('hash'):
-                yield Token(end_of_line_type,m.group('commentend'),
-                            filename,lineno)
-            elif m.group('endline'):
-                yield Token(end_of_line_type,m.group('endline'),
-                            filename,lineno)
-            elif m.group('oper'):
-                yield Token('oper',m.group('oper'),filename,lineno)
-            elif m.group('filter'):
-                yield Token('oper','.'+m.group('filter')+'.',filename,lineno)
-            elif m.group('varname'):
-                yield Token('varname',m.group('varname'),filename,lineno)
-            elif m.group('number'):
-                yield Token('number',m.group('number'),filename,lineno)
-            elif m.group('empty_qstring'):
-                yield Token('qstring','',filename,lineno)
-            elif m.group('empty_dqstring'):
-                yield Token('dqstring','',filename,lineno)
-            elif m.group('qstring'):
-                yield Token('qstring',m.group('qstring'),filename,lineno)
-            elif m.group('dqstring'):
-                yield Token('dqstring',m.group('dqstring'),filename,lineno)
-            elif m.group('bracestring'):
-                yield Token('bracestring',m.group('bracestring'),
-                            filename,lineno)
-            elif m.group('at'):
-                yield Token('@','@',filename,lineno)
-            elif m.group('equalequal'):
-                yield Token('==','==',filename,lineno)
-            elif m.group('equal'):
-                yield Token('=','=',filename,lineno)
-            elif m.group('comma'):
-                yield Token(',',',',filename,lineno)
-            elif m.group('colon'):
-                yield Token(':',':',filename,lineno)
-            elif m.group('lset'):
-                yield Token('{','{',filename,lineno)
-            elif m.group('rset'):
-                yield Token('}','}',filename,lineno)
-            elif m.group('lparen'):
-                yield Token('(','(',filename,lineno)
-            elif m.group('rparen'):
-                yield Token(')',')',filename,lineno)
-            elif m.group('lfort'):
-                yield Token('(/','(/',filename,lineno)
-            elif m.group('rfort'):
-                yield Token('/)','/)',filename,lineno)
-            elif m.group('whitespace'):
-                pass # Ignore whitespace outside strings
-            else:
-                raise ValueError('%s:%d: invalid text %s'%(
-                        filename,lineno,repr(m.group(0))))
-            lineno+=m.group(0).count('\n')
-        yield Token(end_of_text_type,'',filename,lineno)
-
-class TokenizeFile(object):
-    """!Wrapper around a Tokenizer for a specified file.
-
-    This is a convenience class; it is a wrapper around a Tokenizer,
-    but also knows how to create new TokenizeFile objects for the same
-    type of underlyting Tokenizer objects (for_file())."""
-
-    ##@var tokenizer
-    # The Tokenizer object that turns text into sequences of Token objects.
-    
-    ##@var fileobj
-    # A file-like object that produces text for the tokenizer
-
-    ##@var filename
-    # The name of the file that fileobj reads.
-
-    ##@var first_line
-    # The integer first line of the file, usually 1.
-
-    def __init__(self,tokenizer,fileobj,
-                 filename=produtil.testing.utilities.unknown_file,
-                 first_line=1):
-        """!Constructor for TokenizeFile
-        @param tokenizer The Tokenizer-like object to parse.
-        @param fileobj The opened file-like object to read.
-        @param filename The file from which the text originates.  This may be used
-          for two purposes.  The first is error reporting, and the second is 
-          "load" statements, which load files relative to the path to the 
-          current file.
-        @param first_line The line number for the first line of the file."""
-        self.tokenizer=tokenizer
-        self.fileobj=fileobj
-        self.filename=filename
-        self.first_line=first_line
-    def for_file(self,fileobj,filename,first_line=1):
-        """!Creates a new TokenizeFile object for the specified file.
-
-        @param fileobj The file-like object to read.
-        @param filename The file from which the text originates.  This
-          may be used for two purposes.  The first is error reporting,
-          and the second is "load" statements, which load files
-          relative to the path to the current file.
-        @param first_line The line number for the first line of the file."""
-        return TokenizeFile(self.tokenizer.copy(),fileobj,filename,first_line)
-    def __iter__(self):
-        """!Iterates over tokens in self.fileobj."""
-        text=self.fileobj.read()
-        for token in self.tokenizer.tokenize(
-            text,self.filename,self.first_line):
-            yield token
-
-
-
diff --git a/produtil/testing/utilities.py b/produtil/testing/utilities.py
deleted file mode 100644
index d9ffa102a0..0000000000
--- a/produtil/testing/utilities.py
+++ /dev/null
@@ -1,304 +0,0 @@
-"""!Common utilities used by other parts of the produtil.testing package."""
-        
-import sys, re, io, collections, os, datetime, logging
-
-##@var __all__
-# List of variables exported by "from produtil.testing.utilities import *"
-__all__=[ 'module_logger', 'BASELINE', 'EXECUTION', 'elipses', 'splitkey',
-          'dqstring2bracestring', 'is_valid_workflow_name', 'unknown_file',
-          'peekable','bashify_string', 'ListableSet', 'PTParserError',
-          'PTKeyError', 'PTPlatformError' ]
-
-class PTParserError(Exception): pass
-class PTPlatformError(PTParserError): pass
-class PTKeyError(PTParserError,KeyError): pass
-
-# def yell(arg):
-#     """!Unused; needs to be removed.
-
-#     @todo Remove this function."""
-#     pass 
-
-##@var module_logger
-# The default logging.Logger to use if no logger is specified.
-module_logger=logging.getLogger('produtil.testing')
-
-##@var BASELINE
-# A constant that indicates the suite is being run to generate a new baseline.
-BASELINE=object()
-
-##@var EXECUTION
-# A constant that indicates the suite is being run to verify against
-# an existing baseline.
-EXECUTION=object()
-
-##@var unknown_file
-# A constant string used for logging purposes to indicate a filename
-# was unspecified or unknown.
-unknown_file='(**unknown**)'
-
-def bashify_string(string):
-        """Given a Python string, express it as a bash string.
-
-        Expresses a python string as a bash string.
-
-        Example:
-
-        @code
-           print bashify_string("123''$$")
-           #  --> prints '123'"''"'$$'
-        @endcode
-
-        @param string Any subclass of str
-
-        @returns valid bash code to represent the string"""
-        output=io.StringIO()
-        for m in re.finditer('''(?xs)
-            (
-                (?P<quotes>'+)
-              | (?P<dquotes>"+)
-              | (?P<printable>[!-&(-\[\]-~ ]+)
-              | (?P<control>.)
-            )''',string):
-            if m.group('quotes'):
-                output.write('"' + m.group('quotes') + '"')
-            elif m.group('dquotes'):
-                output.write("'" + m.group('dquotes') + "'")
-            elif m.group('printable'):
-                output.write("'"+m.group('printable')+"'")
-            elif m.group('control'):
-                output.write("$'\%03o'"%ord(m.group('control')))
-        ret=output.getvalue()
-        output.close()
-        return ret
-
-def elipses(long_string,max_length=40,elipses='...'):
-    """!Returns a shortened version of long_string.
-
-    If long_string is longer than max_length characters, returns a
-    string of length max_length that starts with long_string and ends
-    with elipses.  Hence, the number of characters of long_string that
-    will be used is max_length-len(elipses)
-
-    @param long_string a str or subclass thereof
-    @param max_length maximum length string to return
-    @param elipses the elipses string to append to the end"""
-    strlen=len(long_string)
-    if strlen<max_length:
-        return long_string
-    else:
-        return long_string[0:max_length-len(elipses)]+elipses
-
-def splitkey(key):
-    """!Splits a string on "%" and returns the list, raising an
-    exception if any components are empty.
-
-    @returns a list of substrings of key, split on "%"
-    @param key a string to split
-    @raise ValueError if any substrings are empty"""
-    names=key.split("%")
-    if any([ not s  for  s in names ]):
-        raise ValueError("Empty name component in \"%s\""%(key,))
-    return names
-
-def dqstring2bracestring(dq):
-    """!Converts a bash-style double quote string to a tripple brace
-    string.
-    @param dq The bash-style double quote string, minus the 
-      surrounding double quotes."""
-    output=io.StringIO()
-    for m in re.finditer(r'''(?xs)
-        (
-            \\ (?P<backslashed>.)
-          | (?P<braces> [\]\[]+ )
-          | (?P<text> [^\\@\]\[]+)
-          | (?P<atblock>
-                @ \[ @ \]
-              | @ \[ ' [^']+ ' \]
-              | @ \[ [^\]]+ \]
-            )
-          | (?P<literal_at> @ (?!\[) )
-          | (?P<error> . )
-        ) ''',dq):
-        if m.group('backslashed'):
-            s=m.group('backslashed')
-            if s=='@':
-                output.write('@[@]')
-            elif s in '[]':
-                output.write("@['"+s+"']")
-            else:
-                output.write(s)
-        elif m.group('literal_at'):
-            output.write('@[@]')
-        elif m.group('atblock'):
-            output.write(m.group('atblock'))
-        elif m.group('braces'):
-            output.write("@['"+m.group('braces')+"']")
-        elif m.group('text'):
-            output.write(m.group('text'))
-        else:
-            raise ValueError(
-                'Cannot convert double-quote string \"%s\" to brace string: '
-                'parser error around character \"%s\"."'%(dq,m.group()))
-    value=output.getvalue()
-    output.close()
-    return value
-
-def is_valid_workflow_name(name):
-    """!is this a valid name for a produtil.testing workflow?
-
-    Workflow names have to fit within certain restrictions of workflow
-    automation suites.  For this reason, we restrict names to begin
-    with a letter and only contain letters, numbers and
-    underscores.
-    @param name the name to check
-    @returns True if the name meets requirements and False otherwise"""
-    return bool(re.match('(?s)^[a-zA-Z][a-zA-Z0-9_]*$',name))
-
-##@var NO_VALUE
-# Special constant used by peekable to indicate nothing has been peeked yet.
-# @warning Terrible things will happen if you overwrite this.
-# @private
-NO_VALUE=object()
-
-class peekable(object):
-    """!An iter-like object that has a peek() method to peek at the
-    next token without consuming it.
-
-    Example:
-
-    @code
-        a=peekable("12345")
-        a.next() # 1
-        a.next() # 2
-        a.next() # 3
-        a.peek() # 4 <--- peeks at next element
-        a.next() # 4 <--- peek() did not consume 4, so next() returns 4
-        a.next() # 5
-    @endcode
-    """
-    def __init__(self,iterator):
-        """!Constructor for peekable
-        @param iterator any iterable object"""
-        self.__child=iterator
-        self.__iterator=iter(iterator)
-        self.__peek=NO_VALUE
-        self.__prior=NO_VALUE
-
-    def has_prior(self):
-            return self.__prior is not NO_VALUE
-
-    def prior(self):
-            if self.__prior is not NO_VALUE:
-                    return self.__prior
-            else:
-                    return NO_VALUE
-
-    def __next__(self):
-        """!Advances the iterator to the next value and returns it"""
-        if self.__peek is not NO_VALUE:
-            p,self.__peek = self.__peek,NO_VALUE
-        else:
-            p=next(self.__iterator)
-        self.__prior=p
-        return p
-    def peek(self):
-        """!Returns the next value in the iterator or raises StopIteration"""
-        if self.__peek is NO_VALUE:
-            self.__peek=next(self.__iterator)
-        return self.__peek
-    def at_end(self):
-        """!Returns True if the iterator has reached the last value"""
-        if self.__peek is not NO_VALUE:
-            return False
-        try:
-            self.__peek=next(self.__iterator)
-        except StopIteration as se:
-            return True
-        return False
-    def __iter__(self):
-        """!Iterates over all remaining values."""
-        p,self.__peek = self.__peek,NO_VALUE
-        if p is not NO_VALUE:
-            yield p
-        for v in self.__iterator:
-            yield v
-
-    @property
-    def child(self): 
-        """!Returns the iterator"""
-        return self.__child
-
-
-    ##@var child
-    # The object being iterated
-
-class ListableSet(object):
-    """!An ordered set."""
-    def __init__(self,contents=None):
-        """!Constructor
-
-        @param contents an iterable object with the elements"""
-        super(ListableSet,self).__init__()
-        if contents is None:
-            self._set=set()
-            self._list=list()
-        else:
-            self._set=set(contents)
-            self._list=list(contents)
-        self._NOTHING=object()
-    def __contains__(self,item):
-        """!Is the item in this set?"""
-        return item in self._set
-    def __iter__(self):
-        """!Iterates over the set's elements in order."""
-        for s in self._list:
-            yield s
-    def __str__(self):
-        """!A string representation of this set in set notation."""
-        return '{ '+', '.join([ repr(s) for s in self._list ])+' }'
-    def __repr__(self):
-        """!A string representation of this set in pythonic notation"""
-        return 'ListableSet([ '+', '.join(
-            [ repr(s) for s in self._list ])+' ])'
-    def add(self,item):
-        """!Adds the item to the end of this set, unless it is already a member"""
-        if item not in self:
-            self._set.add(item)
-            self._list.append(item)
-    def minus(self,other):
-        """!Removes the other set's items from this set."""
-        for s in other:
-            if s in self:
-                self._set.discard(s)
-                self._list.remove(s)
-    def inter(self,other):
-        """!Adds any items from the other set that are not in this set."""
-        remove=set()
-        for s in self:
-            if s not in other:
-                remove.add(s)
-        for s in remove:
-            self._set.discard(s)
-            self._list.remove(s)
-    def union(self,other):
-        """!Performs a set union, adding the other set's items to this
-        set, except those already present.  Preserves the order of the
-        items while adding them by inserting new items in this set after
-        immediately preceeding ones in the other set."""
-        prior=self._NOTHING
-        iprior=-1
-        for s in other:
-            if s in self:
-                prior=s
-                iprior=self._list.index(s)
-            elif prior is not self._NOTHING:
-                self._list.insert(iprior+1,s)
-                self._set.add(s)
-                prior=s
-                iprior=iprior+1
-            else:
-                self._list.append(s)
-                self._set.add(s)
-                prior=s
-                iprior=len(self._list)