dwhswenson · Jan 4, 2021 · Oct 23, 2020 · Oct 23, 2020 · Nov 27, 2020 · Dec 6, 2020
diff --git a/paths_cli/commands/contents.py b/paths_cli/commands/contents.py
@@ -1,19 +1,64 @@
 import click
 from paths_cli.parameters import INPUT_FILE
 
+UNNAMED_SECTIONS = ['steps', 'movechanges', 'samplesets', 'trajectories',
+                    'snapshots']
+
+NAME_TO_ATTR = {
+    'CVs': 'cvs',
+    'Volumes': 'volumes',
+    'Engines': 'engines',
+    'Networks': 'networks',
+    'Move Schemes': 'schemes',
+    'Simulations': 'pathsimulators',
+    'Tags': 'tags',
+    'Steps': 'steps',
+    'Move Changes': 'movechanges',
+    'SampleSets': 'samplesets',
+    'Trajectories': 'trajectories',
+    'Snapshots': 'snapshots'
+}
+
 @click.command(
     'contents',
     short_help="list named objects from an OPS .nc file",
 )
 @INPUT_FILE.clicked(required=True)
-def contents(input_file):
+@click.option('--table', type=str, required=False,
+              help="table to show results from")
+def contents(input_file, table):
     """List the names of named objects in an OPS .nc file.
 
     This is particularly useful when getting ready to use one of simulation
     scripts (i.e., to identify exactly how a state or engine is named.)
     """
     storage = INPUT_FILE.get(input_file)
     print(storage)
+    if table is None:
+        report_all_tables(storage)
+    else:
+        table_attr = table.lower()
+        try:
+            store = getattr(storage, table_attr)
+        except AttributeError:
+            raise click.UsageError("Unknown table: '" + table_attr + "'")
+        else:
+            print(get_section_string(table_attr, store))
+
+
+def get_section_string(label, store):
+    attr = NAME_TO_ATTR.get(label, label.lower())
+    if attr in UNNAMED_SECTIONS:
+        string = get_unnamed_section_string(label, store)
+    elif attr in ['tag', 'tags']:
+        string = get_section_string_nameable(label, store, _get_named_tags)
+    else:
+        string = get_section_string_nameable(label, store,
+                                             _get_named_namedobj)
+    return string
+
+
+def report_all_tables(storage):
     store_section_mapping = {
         'CVs': storage.cvs, 'Volumes': storage.volumes,
         'Engines': storage.engines, 'Networks': storage.networks,
@@ -26,12 +71,16 @@ def contents(input_file):
     print(get_section_string_nameable('Tags', storage.tags, _get_named_tags))
 
     print("\nData Objects:")
-    unnamed_sections = {
-        'Steps': storage.steps, 'Move Changes': storage.movechanges,
-        'SampleSets': storage.samplesets,
-        'Trajectories': storage.trajectories, 'Snapshots': storage.snapshots
+    data_object_mapping = {
+        'Steps': lambda storage: storage.steps,
+        'Move Changes': lambda storage: storage.movechanges,
+        'SampleSets': lambda storage: storage.samplesets,
+        'Trajectories': lambda storage: storage.trajectories,
+        'Snapshots': lambda storage: storage.snapshots
     }
-    for section, store in unnamed_sections.items():
+
+    for section, store_func in data_object_mapping.items():
+        store = store_func(storage)
         print(get_unnamed_section_string(section, store))
 
 def _item_or_items(count):

diff --git a/paths_cli/commands/equilibrate.py b/paths_cli/commands/equilibrate.py
@@ -43,6 +43,7 @@ def equilibrate_main(output_storage, scheme, init_conds, multiplier,
                      extra_steps):
     import openpathsampling as paths
     init_conds = scheme.initial_conditions_from_trajectories(init_conds)
+    scheme.assert_initial_conditions(init_conds)
     simulation = paths.PathSampling(
         storage=output_storage,
         move_scheme=scheme,

diff --git a/paths_cli/param_core.py b/paths_cli/param_core.py
@@ -315,3 +315,51 @@ def get(self, storage, name):
             raise RuntimeError(msg)
 
         return result
+
+
+class OPSStorageLoadMultiple(OPSStorageLoadSingle):
+    """Objects that can guess a single object or have multiple specified.
+
+    Parameters
+    ----------
+    param : :class:`.AbstractParameter`
+        the Option or Argument wrapping a click decorator
+    store : Str
+        the name of the store to search
+    value_strategies : List[Callable[(:class:`.Storage`, Str), Any]]
+        The strategies to be used when the CLI provides a value for this
+        parameter. Each should be a callable taking a storage and the string
+        input from the CLI, and should return the desired object or None if
+        it cannot be found.
+    none_strategies : List[Callable[:class:`openpathsampling.Storage, Any]]
+        The strategies to be used when the CLI does not provide a value for
+        this parameter. Each should be a callable taking a storage, and
+        returning the desired object or None if it cannot be found.
+    """
+    def get(self, storage, names):
+        """Load desired objects from storage.
+
+        Parameters
+        ----------
+        storage : openpathsampling.Storage
+            the input storage to search
+        names : List[Str] or None
+            strings from CLI providing the identifier (name or index) for
+            this object; None if not provided
+        """
+        if names == tuple():
+            names = None
+
+        if names is None or isinstance(names, (str, int)):
+            listified = True
+            names = [names]
+        else:
+            listified = False
+
+        results = [super(OPSStorageLoadMultiple, self).get(storage, name)
+                   for name in names]
+
+        if listified:
+            results = results[0]
+
+        return results
diff --git a/paths_cli/parameters.py b/paths_cli/parameters.py
@@ -1,8 +1,8 @@
 import click
 from paths_cli.param_core import (
-    Option, Argument, OPSStorageLoadSingle, OPSStorageLoadNames,
-    StorageLoader, GetByName, GetByNumber, GetOnly, GetOnlySnapshot,
-    GetPredefinedName
+    Option, Argument, OPSStorageLoadSingle, OPSStorageLoadMultiple,
+    OPSStorageLoadNames, StorageLoader, GetByName, GetByNumber, GetOnly,
+    GetOnlySnapshot, GetPredefinedName
 )
 
 
@@ -18,10 +18,10 @@
     store='schemes',
 )
 
-INIT_CONDS = OPSStorageLoadSingle(
-    param=Option('-t', '--init-conds',
+INIT_CONDS = OPSStorageLoadMultiple(
+    param=Option('-t', '--init-conds', multiple=True,
                  help=("identifier for initial conditions "
-                       + "(sample set or trajectory)")),
+                       + "(sample set or trajectory)" + HELP_MULTIPLE)),
     store='samplesets',
     value_strategies=[GetByName('tags'), GetByNumber('samplesets'),
                       GetByNumber('trajectories')],
@@ -57,7 +57,6 @@
     store='engines'
 )
 
-
 STATES = OPSStorageLoadNames(
     param=Option('-s', '--state', type=str, multiple=True,
                  help='name  of state' + HELP_MULTIPLE),

diff --git a/paths_cli/tests/commands/test_contents.py b/paths_cli/tests/commands/test_contents.py
@@ -40,3 +40,44 @@ def test_contents(tps_fixture):
         assert results.output.split('\n') == expected
         for truth, beauty in zip(expected, results.output.split('\n')):
             assert truth == beauty
+
+@pytest.mark.parametrize('table', ['volumes', 'trajectories', 'tags'])
+def test_contents_table(tps_fixture, table):
+    scheme, network, engine, init_conds = tps_fixture
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        storage = paths.Storage("setup.nc", 'w')
+        for obj in tps_fixture:
+            storage.save(obj)
+        storage.tags['initial_conditions'] = init_conds
+
+        results = runner.invoke(contents, ['setup.nc', '--table', table])
+        cwd = os.getcwd()
+        expected = {
+            'volumes': [
+                f"Storage @ '{cwd}/setup.nc'",
+                "volumes: 8 items", "* A", "* B", "* plus 6 unnamed items",
+                ""
+            ],
+            'trajectories': [
+                f"Storage @ '{cwd}/setup.nc'",
+                "trajectories: 1 unnamed item",
+                ""
+            ],
+            'tags': [
+                f"Storage @ '{cwd}/setup.nc'",
+                "tags: 1 item",
+                "* initial_conditions",
+                ""
+            ],
+        }[table]
+        assert results.output.split("\n") == expected
+        assert results.exit_code == 0
+
+def test_contents_table_error():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        storage = paths.Storage("temp.nc", mode='w')
+        storage.close()
+        results = runner.invoke(contents, ['temp.nc', '--table', 'foo'])
+        assert results.exit_code != 0
diff --git a/paths_cli/tests/commands/test_pathsampling.py b/paths_cli/tests/commands/test_pathsampling.py
@@ -26,10 +26,11 @@ def test_pathsampling(tps_fixture):
 
         results = runner.invoke(pathsampling, ['setup.nc', '-o', 'foo.nc',
                                                '-n', '1000'])
-        assert results.exit_code == 0
         expected_output = (f"True\n{scheme.__uuid__}\n{init_conds.__uuid__}"
                            "\n1000\n")
+
         assert results.output == expected_output
+        assert results.exit_code == 0
 
 
 def test_pathsampling_main(tps_fixture):

diff --git a/paths_cli/tests/test_parameters.py b/paths_cli/tests/test_parameters.py
@@ -234,6 +234,14 @@ def test_get_none(self, num_in_file):
         obj = INIT_CONDS.get(st, None)
         assert obj == stored_things[num_in_file - 1]
 
+    def test_get_multiple(self):
+        filename = self.create_file('number-traj')
+        storage = paths.Storage(filename, mode='r')
+        traj0, traj1 = self.PARAMETER.get(storage, (0, 1))
+        assert traj0 == self.traj
+        assert traj1 == self.other_traj
+
+
 class TestINIT_SNAP(ParamInstanceTest):
     PARAMETER = INIT_SNAP
     def setup(self):