shooting-point-selector compilers

also commenting out TIS networks for now

Author: dwhswenson

paths_cli/compiling/_gendocs/docs_generator.py

@@ -104,7 +104,7 @@ def generate_plugin_rst(self, plugin, category_name,
             default="",
             description="name this object in order to reuse it",
         )
-        rst += self.format_parameter(name_param, type_str=" (*string*)")
+        rst += self.format_parameter(name_param, type_str=" (string)")
         for param in plugin.parameters:
             type_str = f" ({json_type_to_string(param.json_type)})"
             rst += self.format_parameter(param, type_str)

paths_cli/compiling/networks.py

@@ -69,24 +69,22 @@ def tis_trans_info(dct):
 )
 
 
-MISTIS_NETWORK_PLUGIN = NetworkCompilerPlugin(
-    parameters=[Parameter('trans_info', mistis_trans_info)],
-    builder=Builder('openpathsampling.MISTISNetwork'),
-    name='mistis'
-)
+# MISTIS_NETWORK_PLUGIN = NetworkCompilerPlugin(
+#     parameters=[Parameter('trans_info', mistis_trans_info)],
+#     builder=Builder('openpathsampling.MISTISNetwork'),
+#     name='mistis'
+# )
 
 
-TIS_NETWORK_PLUGIN = NetworkCompilerPlugin(
-    builder=Builder('openpathsampling.MISTISNetwork'),
-    parameters=[Parameter('trans_info', tis_trans_info)],
-    name='tis'
-)
+# TIS_NETWORK_PLUGIN = NetworkCompilerPlugin(
+#     builder=Builder('openpathsampling.MISTISNetwork'),
+#     parameters=[Parameter('trans_info', tis_trans_info)],
+#     name='tis'
+# )
 
 # old names not yet replaced in testing  THESE ARE WHY WE'RE DOUBLING! GET
 # RID OF THEM! (also, use an is-check)
 build_tps_network = TPS_NETWORK_PLUGIN
-build_mistis_network = MISTIS_NETWORK_PLUGIN
-build_tis_network = TIS_NETWORK_PLUGIN
 
 
 NETWORK_COMPILER = CategoryPlugin(NetworkCompilerPlugin, aliases=['networks'])

paths_cli/compiling/plugins.py

@@ -45,3 +45,11 @@ class SchemeCompilerPlugin(InstanceCompilerPlugin):
 
 class StrategyCompilerPlugin(InstanceCompilerPlugin):
     category = 'strategy'
+
+
+class ShootingPointSelectorPlugin(InstanceCompilerPlugin):
+    category = 'shooting-point-selector'
+
+
+class InterfaceSetPlugin(InstanceCompilerPlugin):
+    category = 'interface-set'

paths_cli/compiling/root_compiler.py

@@ -70,8 +70,8 @@ def _get_compiler(category):
     canonical_name = _canonical_name(category)
     # create a new compiler if none exists
     if canonical_name is None:
-        canonical_name = category
-        _COMPILERS[category] = CategoryCompiler(None, category)
+        canonical_name = clean_input_key(category)
+        _COMPILERS[canonical_name] = CategoryCompiler(None, category)
     return _COMPILERS[canonical_name]
 
 

paths_cli/compiling/shooting.py

@@ -3,9 +3,10 @@
 )
 from paths_cli.compiling.root_compiler import compiler_for
 from paths_cli.compiling.tools import custom_eval
+from paths_cli.compiling.plugins import ShootingPointSelectorPlugin
 
 
-build_uniform_selector = InstanceCompilerPlugin(
+build_uniform_selector = ShootingPointSelectorPlugin(
     builder=Builder('openpathsampling.UniformSelector'),
     parameters=[],
     name='uniform',
@@ -19,7 +20,7 @@ def _remapping_gaussian_stddev(dct):
     return dct
 
 
-build_gaussian_selector = InstanceCompilerPlugin(
+build_gaussian_selector = ShootingPointSelectorPlugin(
     builder=Builder('openpathsampling.GaussianBiasSelector',
                     remapper=_remapping_gaussian_stddev),
     parameters=[
@@ -31,10 +32,10 @@ def _remapping_gaussian_stddev(dct):
 )
 
 
-shooting_selector_compiler = CategoryCompiler(
-    type_dispatch={
-        'uniform': build_uniform_selector,
-        'gaussian': build_gaussian_selector,
-    },
-    label='shooting-selectors'
-)
+# shooting_selector_compiler = CategoryCompiler(
+#     type_dispatch={
+#         'uniform': build_uniform_selector,
+#         'gaussian': build_gaussian_selector,
+#     },
+#     label='shooting-point-selectors'
+# )

paths_cli/compiling/strategies.py

@@ -1,11 +1,13 @@
 from paths_cli.compiling.core import Builder, Parameter
-from paths_cli.compiling.shooting import shooting_selector_compiler
+# from paths_cli.compiling.shooting import shooting_selector_compiler
 from paths_cli.compiling.plugins import (
     StrategyCompilerPlugin, CategoryPlugin
 )
 from paths_cli.compiling.root_compiler import compiler_for
 from paths_cli.compiling.json_type import json_type_ref
 
+shooting_selector_compiler = compiler_for('shooting-point-selector')
+
 
 def _strategy_name(class_name):
     return f"openpathsampling.strategies.{class_name}"

paths_cli/tests/compiling/test_root_compiler.py

@@ -20,29 +20,34 @@
 def foo_compiler():
     return CategoryCompiler(None, 'foo')
 
+
 @pytest.fixture
 def foo_compiler_plugin():
     return CategoryPlugin(Mock(category='foo', __name__='foo'), ['bar'])
 
+
 @pytest.fixture
 def foo_baz_builder_plugin():
-    builder = InstanceCompilerPlugin(lambda: "FOO" , [], name='baz',
+    builder = InstanceCompilerPlugin(lambda: "FOO", [], name='baz',
                                      aliases=['qux'])
     builder.category = 'foo'
     return builder
 
+
 ### CONSTANTS ##############################################################
 
 COMPILER_LOC = "paths_cli.compiling.root_compiler._COMPILERS"
 BASE = "paths_cli.compiling.root_compiler."
 
+
 ### TESTS ##################################################################
 
 @pytest.mark.parametrize('input_string', ["foo-bar", "FOO_bar", "foo  bar",
                                           "foo_bar", "foo BAR"])
 def test_clean_input_key(input_string):
     assert clean_input_key(input_string) == "foo_bar"
 
+
 @pytest.mark.parametrize('input_name', ['canonical', 'alias'])
 def test_canonical_name(input_name):
     compilers = {'canonical': "FOO"}
@@ -51,6 +56,7 @@ def test_canonical_name(input_name):
             patch.dict(BASE + "_ALIASES", aliases) as aliases_:
         assert _canonical_name(input_name) == "canonical"
 
+
 class TestCategoryCompilerProxy:
     def setup(self):
         self.compiler = CategoryCompiler(None, "foo")
@@ -86,6 +92,7 @@ def _bar_dispatch(dct):
         with patch.dict(COMPILER_LOC, {'foo': foo_compiler}):
             assert proxy(user_input) == "bazbaz"
 
+
 def test_compiler_for_nonexisting():
     # if nothing is ever registered with the compiler, then compiler_for
     # should error
@@ -97,20 +104,23 @@ def test_compiler_for_nonexisting():
         with pytest.raises(RuntimeError, match="No CategoryCompiler"):
             proxy._proxy
 
+
 def test_compiler_for_existing(foo_compiler):
     # if a compiler already exists when compiler_for is called, then
     # compiler_for should get that as its proxy
     with patch.dict(COMPILER_LOC, {'foo': foo_compiler}):
         proxy = compiler_for('foo')
         assert proxy._proxy is foo_compiler
 
+
 def test_compiler_for_unregistered(foo_compiler):
     # if a compiler is registered after compiler_for is called, then
     # compiler_for should use that as its proxy
     proxy = compiler_for('foo')
     with patch.dict(COMPILER_LOC, {'foo': foo_compiler}):
         assert proxy._proxy is foo_compiler
 
+
 def test_compiler_for_registered_alias(foo_compiler):
     # if compiler_for is registered as an alias, compiler_for should still
     # get the correct compiler
@@ -121,12 +131,14 @@ def test_compiler_for_registered_alias(foo_compiler):
         proxy  = compiler_for('bar')
         assert proxy._proxy is foo_compiler
 
+
 def test_get_compiler_existing(foo_compiler):
     # if a compiler has been registered, then _get_compiler should return the
     # registered compiler
     with patch.dict(COMPILER_LOC, {'foo': foo_compiler}):
         assert _get_compiler('foo') is foo_compiler
 
+
 def test_get_compiler_nonexisting(foo_compiler):
     # if a compiler has not been registered, then _get_compiler should create
     # the compiler
@@ -136,6 +148,18 @@ def test_get_compiler_nonexisting(foo_compiler):
         assert compiler.label == 'foo'
         assert 'foo' in _COMPILERS
 
+
+def test_get_compiler_nonstandard_name_multiple():
+    # regression test based on real issue -- there was an error where
+    # non-canonical names (e.g., names that involved hyphens instead of
+    # underscores) would overwrite the previously created compiler instead
+    # of getting the identical object
+    with patch.dict(COMPILER_LOC, {}):
+        c1 = _get_compiler('non-canonical-name')
+        c2 = _get_compiler('non-canonical-name')
+        assert c1 is c2
+
+
 @pytest.mark.parametrize('canonical,aliases,expected', [
     ('foo', ['bar', 'baz'], ['foo', 'bar', 'baz']),
     ('foo', ['baz', 'bar'], ['foo', 'baz', 'bar']),
@@ -149,6 +173,7 @@ def test_get_registration_names(canonical, aliases, expected):
     type(plugin).name = PropertyMock(return_value=canonical)
     assert _get_registration_names(plugin) == expected
 
+
 def test_register_compiler_plugin(foo_compiler_plugin):
     # _register_compiler_plugin should register compilers that don't exist
     compilers = {}
@@ -162,6 +187,7 @@ def test_register_compiler_plugin(foo_compiler_plugin):
 
     assert 'foo' not in _COMPILERS
 
+
 @pytest.mark.parametrize('duplicate_of', ['canonical', 'alias'])
 @pytest.mark.parametrize('duplicate_from', ['canonical', 'alias'])
 def test_register_compiler_plugin_duplicate(duplicate_of, duplicate_from):
@@ -184,6 +210,7 @@ def test_register_compiler_plugin_duplicate(duplicate_of, duplicate_from):
         with pytest.raises(CategoryCompilerRegistrationError):
             _register_compiler_plugin(plugin)
 
+
 @pytest.mark.parametrize('compiler_exists', [True, False])
 def test_register_builder_plugin(compiler_exists, foo_baz_builder_plugin,
                                  foo_compiler):
@@ -203,6 +230,7 @@ def test_register_builder_plugin(compiler_exists, foo_baz_builder_plugin,
         assert type_dispatch['baz'] is foo_baz_builder_plugin
         assert type_dispatch['qux'] is foo_baz_builder_plugin
 
+
 def test_register_plugins_unit(foo_compiler_plugin, foo_baz_builder_plugin):
     # register_plugins should correctly sort builder and compiler plugins,
     # and call the correct registration functions
@@ -212,6 +240,7 @@ def test_register_plugins_unit(foo_compiler_plugin, foo_baz_builder_plugin):
         assert builder.called_once_with(foo_baz_builder_plugin)
         assert compiler.called_once_with(foo_compiler_plugin)
 
+
 def test_register_plugins_integration(foo_compiler_plugin,
                                       foo_baz_builder_plugin):
     # register_plugins should correctly register plugins
@@ -225,6 +254,7 @@ def test_register_plugins_integration(foo_compiler_plugin,
         type_dispatch = _COMPILERS['foo'].type_dispatch
         assert type_dispatch['baz'] is foo_baz_builder_plugin
 
+
 def test_sort_user_categories():
     # sorted user categories should match the expected compile order
     aliases = {'quux': 'qux'}
@@ -245,6 +275,7 @@ def test_sort_user_categories():
         # check that we unset properly (test the test)
         assert paths_cli.compiling.root_compiler.COMPILE_ORDER[0] == 'engine'
 
+
 def test_do_compile():
     # compiler should correctly compile a basic input dict
     compilers = {