Merge pull request #54 from dwhswenson/wizard-rewrite

Wizard rewrite

Author: dwhswenson

paths_cli/commands/wizard.py

@@ -1,12 +1,20 @@
 import click
+from paths_cli.wizard.plugin_registration import register_installed_plugins
 from paths_cli.wizard.two_state_tps import TWO_STATE_TPS_WIZARD
+from paths_cli import OPSCommandPlugin
 
 @click.command(
     'wizard',
     short_help="run wizard for setting up simulations",
 )
 def wizard():  # no-cov
+    register_installed_plugins()
     TWO_STATE_TPS_WIZARD.run_wizard()
 
-CLI = wizard
-SECTION = "Simulation setup"
+
+PLUGIN = OPSCommandPlugin(
+    command=wizard,
+    section="Simulation setup",
+    requires_ops=(1, 0),
+    requires_cli=(0, 3)
+)

paths_cli/compiling/volumes.py

@@ -13,6 +13,8 @@ def cv_volume_build_func(**dct):
     builder = paths.CVDefinedVolume
     if cv.period_min is not None or cv.period_max is not None:
         builder = paths.PeriodicCVDefinedVolume
+        dct['period_min'] = cv.period_min
+        dct['period_max'] = cv.period_max
 
     dct['collectivevariable'] = dct.pop('cv')
     # TODO: wrap this with some logging

paths_cli/plugin_management.py

@@ -7,7 +7,6 @@
 class PluginRegistrationError(RuntimeError):
     pass
 
-# TODO: make more generic than OPS (requires_ops => requires_lib)
 class Plugin(object):
     """Generic plugin object
 

paths_cli/tests/compiling/test_volumes.py

@@ -3,7 +3,10 @@
 from paths_cli.tests.compiling.utils import mock_compiler
 
 import yaml
+import numpy as np
 import openpathsampling as paths
+from openpathsampling.experimental.storage.collective_variables import \
+        CoordinateFunctionCV
 from openpathsampling.tests.test_helpers import make_1d_traj
 
 from paths_cli.compiling.volumes import *
@@ -13,7 +16,6 @@ def setup(self):
         self.yml = "\n".join(["type: cv-volume", "cv: {func}",
                               "lambda_min: 0", "lambda_max: 1"])
 
-        self.mock_cv = mock.Mock(return_value=0.5)
         self.named_objs_dict = {
             'foo': {'name': 'foo',
                     'type': 'bar',
@@ -40,16 +42,29 @@ def test_build_cv_volume(self, inline, periodic):
         self.set_periodic(periodic)
         yml = self.yml.format(func=self.func[inline])
         dct = yaml.load(yml, Loader=yaml.FullLoader)
+        period_min, period_max = {'periodic': (-np.pi, np.pi),
+                                  'nonperiodic': (None, None)}[periodic]
+        mock_cv = CoordinateFunctionCV(lambda s: s.xyz[0][0],
+                                       period_min=period_min,
+                                       period_max=period_max).named('foo')
         if inline =='external':
             patch_loc = 'paths_cli.compiling.root_compiler._COMPILERS'
             compilers = {
-                'cv': mock_compiler('cv', named_objs={'foo': self.mock_cv})
+                'cv': mock_compiler('cv', named_objs={'foo': mock_cv})
             }
             with mock.patch.dict(patch_loc, compilers):
                 vol = build_cv_volume(dct)
         elif inline == 'internal':
             vol = build_cv_volume(dct)
-        assert vol.collectivevariable(1) == 0.5
+
+        in_state = make_1d_traj([0.5])[0]
+        assert vol.collectivevariable(in_state) == 0.5
+        assert vol(in_state)
+        out_state = make_1d_traj([2.0])[0]
+        assert vol.collectivevariable(out_state) == 2.0
+        assert not vol(out_state)
+        if_periodic = make_1d_traj([7.0])[0]
+        assert (vol(if_periodic) == (periodic == 'periodic'))
         expected_class = {
             'nonperiodic': paths.CVDefinedVolume,
             'periodic': paths.PeriodicCVDefinedVolume

paths_cli/tests/wizard/test_cvs.py

@@ -7,8 +7,8 @@
 from paths_cli.tests.wizard.mock_wizard import mock_wizard
 
 from paths_cli.wizard.cvs import (
-    _get_topology, _get_atom_indices, distance, angle, dihedral, rmsd,
-    coordinate, cvs, SUPPORTED_CVS
+    TOPOLOGY_CV_PREREQ, _get_atom_indices, MDTRAJ_DISTANCE, MDTRAJ_ANGLE,
+    MDTRAJ_DIHEDRAL, COORDINATE_CV
 )
 
 import openpathsampling as paths
@@ -17,7 +17,7 @@
 from openpathsampling.tests.test_helpers import make_1d_traj
 
 @pytest.mark.parametrize('n_engines', [0, 1, 2])
-def test_get_topology(ad_engine, n_engines):
+def test_TOPOLOGY_CV_PREREQ(ad_engine, n_engines):
     inputs = {0: [], 1: [], 2: ['1']}[n_engines]
     wizard = mock_wizard(inputs)
     engines = [ad_engine, paths.engines.NoEngine(None).named('foo')]
@@ -27,9 +27,10 @@ def mock_register(obj, obj_type, store_name):
     wizard.register = mock_register
 
     mock_engines = mock.Mock(return_value=ad_engine)
-    patch_loc = 'paths_cli.wizard.engines.engines'
+    patch_loc = 'paths_cli.wizard.cvs.TOPOLOGY_CV_PREREQ.create_func'
     with mock.patch(patch_loc, new=mock_engines):
-        topology = _get_topology(wizard)
+        topology_result = TOPOLOGY_CV_PREREQ(wizard)
+    topology = topology_result['topology'][0]
     assert isinstance(topology, paths.engines.MDTrajTopology)
 
 @pytest.mark.parametrize('inputs', [
@@ -58,37 +59,31 @@ def test_distance(ad_openmm, ad_engine):
     md = pytest.importorskip('mdtraj')
     wizard = mock_wizard(['0, 1'])
     md_func = partial(md.compute_distances, atom_pairs=[[0, 1]])
-    _mdtraj_function_test(wizard, distance, md_func, ad_openmm, ad_engine)
+    _mdtraj_function_test(wizard, MDTRAJ_DISTANCE, md_func, ad_openmm,
+                          ad_engine)
 
 def test_angle(ad_openmm, ad_engine):
     md = pytest.importorskip('mdtraj')
     wizard = mock_wizard(['0, 1, 2'])
     md_func = partial(md.compute_angles, angle_indices=[[0, 1, 2]])
-    _mdtraj_function_test(wizard, angle, md_func, ad_openmm, ad_engine)
+    _mdtraj_function_test(wizard, MDTRAJ_ANGLE, md_func, ad_openmm, ad_engine)
 
 def test_dihedral(ad_openmm, ad_engine):
     md = pytest.importorskip('mdtraj')
     wizard = mock_wizard(['0, 1, 2, 3'])
     md_func = partial(md.compute_dihedrals, indices=[[0, 1, 2, 3]])
-    _mdtraj_function_test(wizard, dihedral, md_func, ad_openmm, ad_engine)
+    _mdtraj_function_test(wizard, MDTRAJ_DIHEDRAL, md_func, ad_openmm,
+                          ad_engine)
 
 @pytest.mark.parametrize('inputs', [
     (['0', 'x']), ('foo', '0', 'x'), (['0', 'q', 'x'])
 ])
 def test_coordinate(inputs):
     wizard = mock_wizard(inputs)
-    cv = coordinate(wizard)
+    cv = COORDINATE_CV(wizard)
     traj = make_1d_traj([5.0])
     assert cv(traj[0]) == 5.0
     if 'foo' in inputs:
         assert "I can't make an atom index" in wizard.console.log_text
     if 'q' in inputs:
         assert "Please select one of" in wizard.console.log_text
-
-@pytest.mark.parametrize('inputs', [(['foo', 'Distance']), (['Distance'])])
-def test_cvs(inputs):
-    wizard = mock_wizard(inputs)
-    say_hello = mock.Mock(return_value="hello")
-    with mock.patch.dict(SUPPORTED_CVS, {'Distance': say_hello}):
-        assert cvs(wizard) == "hello"
-        assert wizard.console.input_call_count == len(inputs)

paths_cli/tests/wizard/test_engines.py

@@ -0,0 +1,99 @@
+import pytest
+
+from paths_cli.wizard.helper import *
+from paths_cli.wizard.helper import _LONG_EVAL_HELP
+
+def test_raise_quit():
+    with pytest.raises(QuitWizard):
+        raise_quit("foo", None)
+
+def test_restart():
+    with pytest.raises(RestartObjectException):
+        raise_restart("foo", None)
+
+def test_force_exit():
+    with pytest.raises(SystemExit):
+        force_exit("foo", None)
+
+class TestEvalHelperFunc:
+    def setup(self):
+        self.param_helper = {
+            'str': "help_string",
+            'method': lambda help_args, context: f"help_{help_args}"
+        }
+        self.expected = {
+            'str': "help_string",
+            'method': "help_foo"
+        }
+
+    @pytest.mark.parametrize('helper_type', ['str', 'method'])
+    def test_call(self, helper_type):
+        help_func = EvalHelperFunc(self.param_helper[helper_type])
+        help_str = help_func("foo")
+        assert self.expected[helper_type] in help_str
+        assert "ask for help with '?eval'" in help_str
+
+    @pytest.mark.parametrize('helper_type', ['str', 'method'])
+    def test_call_eval(self, helper_type):
+        help_func = EvalHelperFunc(self.param_helper[helper_type])
+        assert help_func("eval") == _LONG_EVAL_HELP
+
+class TestHelper:
+    def setup(self):
+        self.helper = Helper(help_func=lambda s, ctx: s)
+
+    def test_help_string(self):
+        # if the helper "function" is a string, return that string whether
+        # or not additional arguments to help are given
+        helper = Helper(help_func="a string")
+        assert helper("?") == "a string"
+        assert helper("?foo") == "a string"
+
+    def test_help_with_args(self):
+        # if the helper can process arguments, do so (our example return the
+        # input)
+        assert self.helper("?foo") == "foo"
+
+    def test_command_help_empty(self):
+        # when calling help with "?!", get the list of commands
+        assert "The following commands can be used" in self.helper("?!")
+
+    @pytest.mark.parametrize('inp', ["?!q", "?!quit"])
+    def test_command_help_for_command(self, inp):
+        # when calling help on a specific command, get the help for that
+        # command
+        assert "The !quit command" in self.helper(inp)
+
+    def test_command_help_no_such_command(self):
+        # if asking for help on an unknown command, report that there is no
+        # help available for it
+        assert "No help for" in self.helper("?!foo")
+
+    @pytest.mark.parametrize('inp', ["!q", "!quit"])
+    def test_run_command_quit(self, inp):
+        # run the quit command when asked to
+        with pytest.raises(QuitWizard):
+            self.helper(inp)
+
+    @pytest.mark.parametrize('inp', ["!!q", "!!quit"])
+    def test_run_command_force_quit(self, inp):
+        # run the force quit command when asked to
+        with pytest.raises(SystemExit):
+            self.helper(inp)
+
+    def test_run_command_restart(self):
+        # run the restart command when asked to
+        with pytest.raises(RestartObjectException):
+            self.helper("!restart")
+
+    def test_run_command_unknown(self):
+        # unknown command names should just report an unknown command
+        assert "Unknown command" in self.helper("!foo")
+
+    def test_run_command_no_argument(self):
+        assert "Please provide a command. The following" in self.helper("!")
+
+    def test_empty_helper(self):
+        empty = Helper(help_func=None)
+        assert "no help available" in empty("?")
+        assert "no help available" in empty("?foo")

paths_cli/tests/wizard/test_helper.py

@@ -45,12 +45,11 @@ def ops_file_fixture():
     return storage
 
 def test_named_objs_helper(ops_file_fixture):
-    wizard = mock_wizard([])
     helper_func = named_objs_helper(ops_file_fixture, 'foo')
-    helper_func(wizard, 'any')
-    assert "what I found" in wizard.console.log_text
-    assert "bar" in wizard.console.log_text
-    assert "baz" in wizard.console.log_text
+    result = helper_func('any')
+    assert "what I found" in result
+    assert "bar" in result
+    assert "baz" in result
 
 @pytest.mark.parametrize('with_failure', [False, True])
 def test_get_ops_storage(tmpdir, with_failure):

paths_cli/tests/wizard/test_load_from_ops.py

@@ -5,59 +5,18 @@
 from paths_cli.tests.utils import assert_url
 
 from paths_cli.wizard.openmm import (
-    _load_openmm_xml, _load_topology, openmm, OPENMM_SERIALIZATION_URL
+    OPENMM_PLUGIN, OPENMM_SERIALIZATION_URL
 )
 
 from paths_cli.compat.openmm import mm, HAS_OPENMM
 
 def test_helper_url():
     assert_url(OPENMM_SERIALIZATION_URL)
 
-@pytest.mark.parametrize('obj_type', ['system', 'integrator', 'foo'])
-def test_load_openmm_xml(ad_openmm, obj_type):
-    # switch back to importorskip when we drop OpenMM < 7.6
-    if not HAS_OPENMM:
-        pytest.skip("could not import openmm")
-    # mm = pytest.importorskip("simtk.openmm")
-    filename = f"{obj_type}.xml"
-    inputs = [filename]
-    expected_count = 1
-    if obj_type == 'foo':
-        inputs.append('integrator.xml')
-        expected_count = 2
-
-    wizard = mock_wizard(inputs)
-    superclass = {'integrator': mm.CustomIntegrator,
-                  'system': mm.System,
-                  'foo': mm.CustomIntegrator}[obj_type]
-    with ad_openmm.as_cwd():
-        obj = _load_openmm_xml(wizard, obj_type)
-        assert isinstance(obj, superclass)
-
-    assert wizard.console.input_call_count == expected_count
-
-@pytest.mark.parametrize('setup', ['normal', 'bad_filetype', 'no_file'])
-def test_load_topology(ad_openmm, setup):
-    import openpathsampling as paths
-    inputs = {'normal': [],
-              'bad_filetype': ['foo.bar'],
-              'no_file': ['foo.pdb']}[setup]
-    expected_text = {'normal': "PDB file",
-                     'bad_filetype': 'trr',
-                     'no_file': 'No such file'}[setup]
-    inputs += ['ad.pdb']
-    wizard = mock_wizard(inputs)
-    with ad_openmm.as_cwd():
-        top = _load_topology(wizard)
-
-    assert isinstance(top, paths.engines.MDTrajTopology)
-    assert wizard.console.input_call_count == len(inputs)
-    assert expected_text in wizard.console.log_text
-
 def test_openmm(ad_openmm):
-    inputs = ['system.xml', 'integrator.xml', 'ad.pdb', '10', '10000']
+    inputs = ['ad.pdb', 'integrator.xml', 'system.xml', '10', '10000']
     wizard = mock_wizard(inputs)
     with ad_openmm.as_cwd():
-        engine = openmm(wizard)
+        engine = OPENMM_PLUGIN(wizard)
     assert engine.n_frames_max == 10000
     assert engine.n_steps_per_frame == 10