initial CLI setup

Author: dwhswenson

paths_cli/__init__.py

@@ -0,0 +1,89 @@
+# builds off the example of MultiCommand in click's docs
+import collections
+import click
+import os
+
+CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
+
+plugin_folder = os.path.join(os.path.dirname(__file__), 'commands')
+
+class OpenPathSamplingCLI(click.MultiCommand):
+    def __init__(self, *args, **kwargs):
+        self.plugin_folders = [
+            os.path.join(os.path.dirname(__file__), 'commands'),
+            os.path.join(click.get_app_dir("OpenPathSampling",
+                                           force_posix=True),
+                         'cli-plugins')
+        ]
+        self._get_command = {}
+        self._sections = collections.defaultdict(list)
+        plugin_files, command_list = self._list_plugins()
+        for cmd, plugin_file in zip(command_list, plugin_files):
+            command, section = self._load_plugin(plugin_file)
+            self._get_command[cmd] = command
+            self._sections[section].append(cmd)
+        super(OpenPathSamplingCLI, self).__init__(*args, **kwargs)
+
+    def _load_plugin(self, name):
+        ns = {}
+        fn = os.path.join(plugin_folder, name + '.py')
+        with open(fn) as f:
+            code = compile(f.read(), fn, 'exec')
+            eval(code, ns, ns)
+        return ns['CLI'], ns['SECTION']
+
+    def _list_plugins(self):
+        files = []
+        commands = []
+        for filename in os.listdir(plugin_folder):
+            if filename.endswith('.py'):
+                command = filename.replace('_', '-')
+                files.append(filename[:-3])
+                commands.append(command[:-3])
+        return files, commands
+
+
+    def list_commands(self, ctx):
+        return list(self._get_command.keys())
+
+    def get_command(self, ctx, name):
+        name = name.replace('_', '-')  # auto alias to allow - or _
+        return self._get_command.get(name)
+
+    def format_commands(self, ctx, formatter):
+        sec_order = ['Simulation', 'Analysis', 'Miscellaneous']
+        for sec in sec_order:
+            cmds = self._sections.get(sec, [])
+            rows = []
+            for cmd in cmds:
+                command = self.get_command(ctx, cmd)
+                if command is None:
+                    continue
+                rows.append((cmd, command.short_help or ''))
+
+            if rows:
+                with formatter.section(sec + " Commands"):
+                    formatter.write_dl(rows)
+
+
+main_help="""
+OpenPathSampling is a Python library for path sampling simulations. This
+command line tool facilitates common tasks when working with
+OpenPathSampling. To use it, use one of the subcommands below. For example,
+you can get more information about the strip-snapshots (filesize reduction)
+tool with:
+
+    openpathsampling strip-snapshots --help
+"""
+
+def main():
+    cli = OpenPathSamplingCLI(
+        name="openpathsampling",
+        help=main_help,
+        context_settings=CONTEXT_SETTINGS
+    )
+    cli()
+
+if __name__ == '__main__':
+    main()
+    # print("list commands:", cli.list_commands())

paths_cli/cli.py

@@ -0,0 +1,67 @@
+import click
+from paths_cli.parameters import INPUT_FILE
+
+@click.command(
+    'nclist',
+    short_help="list named objects from an OPS .nc file",
+)
+@INPUT_FILE.clicked(required=True)
+def nclist(input_file):
+    """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)
+    store_section_mapping = {
+        'CVs': storage.cvs, 'Volumes': storage.volumes,
+        'Engines': storage.engines, 'Networks': storage.networks,
+        'Move Schemes': storage.schemes,
+        'Simulations': storage.pathsimulators,
+    }
+    for section, store in store_section_mapping.items():
+        print(get_section_string_nameable(section, store,
+                                          _get_named_namedobj))
+    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
+    }
+    for section, store in unnamed_sections.items():
+        print(get_unnamed_section_string(section, store))
+
+def _item_or_items(count):
+    return "item" if count == 1 else "items"
+
+def get_unnamed_section_string(section, store):
+    len_store = len(store)
+    return (section + ": " + str(len_store) + " unnamed "
+            + _item_or_items(len_store))
+
+def _get_named_namedobj(store):
+    return [item.name for item in store if item.is_named]
+
+def _get_named_tags(store):
+    return list(store.keys())
+
+def get_section_string_nameable(section, store, get_named):
+    out_str = ""
+    len_store = len(store)
+    out_str += (section + ": " + str(len_store) + " "
+                + _item_or_items(len_store))
+    named = get_named(store)
+    n_unnamed = len_store - len(named)
+    for name in named:
+        out_str += "\n* " + name
+    if n_unnamed > 0:
+        prefix = "plus " if named else ""
+        out_str += ("\n* " + prefix + str(n_unnamed) + " unnamed "
+                    + _item_or_items(n_unnamed))
+    return out_str
+
+CLI = nclist
+SECTION = "Miscellaneous"

paths_cli/commands/contents.py

@@ -0,0 +1,75 @@
+import click
+from paths_cli.parameters import (
+    INPUT_FILE, OUTPUT_FILE, CVS
+)
+
+from tqdm.auto import tqdm
+
+@click.command(
+    'strip-snapshots',
+    short_help="Remove coordinates/velocities from an OPS storage"
+)
+@INPUT_FILE.clicked(required=True)
+@OUTPUT_FILE.clicked(required=True)
+@CVS.clicked(required=False)
+@click.option('--blocksize', type=int, default=10,
+              help="block size for precomputing CVs")
+def strip_snapshots(input_file, output_file, cv, blocksize):
+    """
+    Remove snapshot information (coordinates, velocities) from INPUT_FILE.
+
+    By giving the --cv option (once for each CV), you can select to only
+    save certain CVs. If you do not give that option, all CVs will be saved.
+    """
+    loaded_cvs = [CVS.get(cv) for cv in cv]
+    return strip_snapshots_main(
+        input_storage=INPUT_FILE.get(input_file),
+        output_storage=OUTPUT_FILE.get(output_file),
+        cvs=loaded_cvs,
+        blocksize=blocksize
+    )
+
+
+def block_precompute_cvs(cvs, proxy_snaps, blocksize):
+    n_snaps = len(proxy_snaps)
+    n_blocks = (n_snaps // blocksize) +1
+
+    blocks = [proxy_snaps[i*blocksize: min((i+1)*blocksize, n_snaps)]
+              for i in range(n_blocks)]
+
+    for block_num in tqdm(range(n_blocks), leave=False):
+        block = blocks[block_num]
+        for cv in cvs:
+            cv.enable_diskcache()
+            _ = cv(block)
+
+
+def strip_snapshots_main(input_storage, output_storage, cvs, blocksize):
+    if not cvs:
+        cvs = list(input_storage.cvs)
+
+    # save template
+    output_storage.save(input_storage.snapshots[0])
+
+    snapshot_proxies = input_storage.snapshots.all().as_proxies()
+    stages = tqdm(['precompute', 'cvs', 'snapshots', 'trajectories',
+                   'steps'])
+    for stage in stages:
+        stages.set_description("%s" % stage)
+        if stage == 'precompute':
+            block_precompute_cvs(cvs, snapshot_proxies, blocksize)
+        else:
+            store_func, inputs = {
+                'cvs': (output_storage.cvs.save, input_storage.cvs),
+                'snapshots': (output_storage.snapshots.mention,
+                              snapshot_proxies),
+                'trajectories': (output_storage.trajectories.mention,
+                                 input_storage.trajectories),
+                'steps': (output_storage.steps.save, input_storage.steps)
+            }[stage]
+            for obj in tqdm(inputs):
+                store_func(obj)
+
+
+CLI = strip_snapshots
+SECTION = "Miscellaneous"

paths_cli/commands/strip_snapshots.py

@@ -0,0 +1,141 @@
+import click
+import openpathsampling as paths
+
+class AbstractParameter(object):
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        if 'required' in kwargs:
+            raise ValueError("Can't set required status now")
+        self.kwargs = kwargs
+
+    def clicked(self, required=False):
+        raise NotImplementedError()
+
+class Option(AbstractParameter):
+    def clicked(self, required=False):
+        return click.option(*self.args, **self.kwargs, required=required)
+
+class Argument(AbstractParameter):
+    def clicked(self, required=False):
+        return click.argument(*self.args, **self.kwargs, required=required)
+
+
+class AbstractLoader(object):
+    def __init__(self, param):
+        self.param = param
+
+    @property
+    def clicked(self):
+        return self.param.clicked
+
+    def get(self, *args, **kwargs):
+        return NotImplementedError()
+
+
+class StorageLoader(AbstractLoader):
+    def __init__(self, param, mode):
+        super(StorageLoader, self).__init__(param)
+        self.mode = mode
+
+    def get(self, name):
+        return paths.Storage(name, mode=self.mode)
+
+
+class OPSStorageLoadNames(AbstractLoader):
+    def __init__(self, param, store):
+        super(OPSStorageLoadNames, self).__init__(param)
+        self.store = store
+
+    def get(self, storage, name):
+        return getattr(storage, self.store)[name]
+
+
+class OPSStorageLoadSingle(OPSStorageLoadNames):
+    def __init__(self, param, store, fallback=None, num_store=None):
+        super(OPSStorageLoadSingle, self).__init__(param, store)
+        self.fallback = fallback
+        if num_store is None:
+            num_store = store
+        self.num_store = num_store
+
+    def get(self, storage, name):
+        store = getattr(storage, self.store)
+
+        result = None
+        # if the we can get by name/number, do it
+        if name is not None:
+            result =  store[name]
+
+            if result is None:
+                try:
+                    num = int(name)
+                except ValueError:
+                    pass
+                else:
+                    num_store = getattr(storage, self.num_store)
+                    result = num_store[num]
+
+        if result is not None:
+            return result
+
+        # if there's only one of them, take that
+        if len(store) == 1:
+            return store[0]
+
+        # if only one is named, take it
+        named_things = [o for o in store if o.name]
+        if len(named_things) == 1:
+            return named_things[0]
+
+        if self.fallback:
+            result = self.fallback(self, storage, name)
+
+        if result is None:
+            raise RuntimeError("Couldn't find %s", name)
+
+        return result
+
+ENGINE = OPSStorageLoadSingle(
+    param=Option('-e', '--engine', help="identifer for the engine"),
+    store='engines',
+    fallback=None  # for now... I'll add more tricks later
+)
+
+SCHEME = OPSStorageLoadSingle(
+    param=Option('-m', '--scheme', help="identifier for the move scheme"),
+    store='schemes',
+    fallback=None
+)
+
+INIT_TRAJ = OPSStorageLoadSingle(
+    param=Option('-t', '--init-traj',
+                 help="identifier for initial trajectory"),
+    store='tags',
+    num_store='trajectories',
+    fallback=None  # for now
+)
+
+CVS = OPSStorageLoadNames(
+    param=Option('--cv', type=str, multiple=True,
+                 help='name of CV; may select more than once'),
+    store='cvs'
+)
+
+STATES = OPSStorageLoadNames(
+    param=Option('-s', '--state', multiple=True,
+                 help='name of state; may select more than once'),
+    store='volumes'
+)
+
+INPUT_FILE = StorageLoader(
+    param=Argument('input_file', type=str),
+    mode='r'
+)
+
+OUTPUT_FILE = StorageLoader(
+    param=Option('-o', '--output-file', type=str, help="output ncfile"),
+    mode='w'
+)
+
+N_STEPS_MC = click.option('-n', '--nsteps', type=int,
+                          help="number of Monte Carlo trials to run")