Seems to work through TPS schemes!

dwhswenson · Sep 27, 2021 · Mar 21, 2021 · Mar 21, 2021 · Mar 21, 2021 · Mar 21, 2021
commit 2ed6990de1b29529bc526b4671abfe597550d32e
diff --git a/paths_cli/commands/contents.py b/paths_cli/commands/contents.py
@@ -19,6 +19,9 @@
     'Snapshots': 'snapshots'
 }
 
+import logging
+logger = logging.getLogger(__name__)
+
 @click.command(
     'contents',
     short_help="list named objects from an OPS .nc file",
@@ -48,6 +51,7 @@ def contents(input_file, table):
 
 def get_section_string(label, store):
     attr = NAME_TO_ATTR.get(label, label.lower())
+    logger.debug(f"Working on {attr}")
     if attr in UNNAMED_SECTIONS:
         string = get_unnamed_section_string(label, store)
     elif attr in ['tag', 'tags']:

diff --git a/paths_cli/parsing/core.py b/paths_cli/parsing/core.py
@@ -22,79 +22,25 @@ def unlistify(obj, listified):
         obj = obj[0]
     return obj
 
-# class NamedObjects(abc.MutableMapping):
-    # """Class to track named objects and their descriptions"""
-    # def __init__(self, global_dct):
-        # names, dcts = self.all_name_descriptions(global_dct)
-        # self.objects = {name: None for name in names}
-        # self.descriptions = {name: dct for name, dct in zip(names, dcts)}
-
-    # def __getitem__(self, key):
-        # return self.objects[key]
-
-    # def __setitem__(self, key, value):
-        # self.objects[key] = value
-
-    # def __delitem__(self, key):
-        # del self.objects[key]
-
-    # def __iter__(self):
-        # return iter(self.objects)
-
-    # def __len__(self):
-        # return len(self.objects)
-
-    # @staticmethod
-    # def all_name_descriptions(dct):
-        # """Find all the named objets and their dict descriptions
-
-        # Parameters
-        # ----------
-        # dct : dict
-            # output from loading YAML
-        # """
-        # names = []
-        # dcts = []
-        # name = None
-        # if isinstance(dct, list):
-            # for item in dct:
-                # name_list, dct_list = \
-                        # NamedObjects.all_name_descriptions(item)
-                # names.extend(name_list)
-                # dcts.extend(dct_list)
-        # elif isinstance(dct, dict):
-            # for k, v in dct.items():
-                # if isinstance(v, (dict, list)):
-                    # name_list, dct_list = \
-                            # NamedObjects.all_name_descriptions(v)
-                    # names.extend(name_list)
-                    # dcts.extend(dct_list)
-            # try:
-                # name = dct['name']
-            # except KeyError:
-                # pass
-            # else:
-                # names.append(name)
-                # dcts.append(dct)
-
-        # return names, dcts
-
-
 class InstanceBuilder:
     # TODO: add schema as an input so we can autogenerate our JSON schema!
-    def __init__(self, builder, attribute_table, defaults=None, module=None,
-                 remapper=None):
+    def __init__(self, builder, attribute_table, optional_attributes=None,
+                 defaults=None, module=None, remapper=None):
         self.module = module
         self.builder = builder
+        self.builder_name = str(self.builder)
         self.attribute_table = attribute_table
+        if optional_attributes is None:
+            optional_attributes = {}
+        self.optional_attributes = optional_attributes
         # TODO use none_to_default
         if remapper is None:
              remapper = lambda x: x
         self.remapper = remapper
         if defaults is None:
             defaults = {}
         self.defaults = defaults
-        self.logger = logging.getLogger(f"parser.InstanceBuilder[{builder}]")
+        self.logger = logging.getLogger(f"parser.InstanceBuilder.{builder}")
 
     def select_builder(self, dct):
         if self.module is not None:
@@ -103,16 +49,30 @@ def select_builder(self, dct):
             builder = self.builder
         return builder
 
-
-    def __call__(self, dct):
+    def _parse_attrs(self, dct):
         # TODO: support aliases in dct[attr]
-        input_dct = self.defaults.copy().update(dct)
-        # new_dct = {attr: func(dct[attr], named_objs)
-                   # for attr, func in self.attribute_table.items()}
+        input_dct = self.defaults.copy()
+        self.logger.debug(f"defaults: {input_dct}")
+        input_dct.update(dct)
+        self.logger.debug(f"effective input: {input_dct}")
+
         new_dct = {}
         for attr, func in self.attribute_table.items():
-            self.logger.debug(f"{attr}: {dct[attr]}")
-            new_dct[attr] = func(dct[attr])
+            try:
+                value = input_dct[attr]
+            except KeyError:
+                raise InputError(f"'{self.builder_name}' missing required "
+                                 f"parameter '{attr}'")
+            self.logger.debug(f"{attr}: {input_dct[attr]}")
+            new_dct[attr] = func(input_dct[attr])
+
+        optionals = set(self.optional_attributes) & set(dct)
+        for attr in optionals:
+            new_dct[attr] = self.attribute_table[attr](dct[attr])
+
+        return new_dct
+
+    def _build(self, new_dct):
         builder = self.select_builder(new_dct)
         ops_dct = self.remapper(new_dct)
         self.logger.debug("Building...")
@@ -121,6 +81,10 @@ def __call__(self, dct):
         self.logger.debug(obj)
         return obj
 
+    def __call__(self, dct):
+        new_dct = self._parse_attrs(dct)
+        return self._build(new_dct)
+
 
 class Parser:
     """Generic parse class; instances for each category"""

diff --git a/paths_cli/parsing/root_parser.py b/paths_cli/parsing/root_parser.py
@@ -3,6 +3,7 @@
 from paths_cli.parsing.cvs import cv_parser
 from paths_cli.parsing.volumes import volume_parser
 from paths_cli.parsing.networks import network_parser
+from paths_cli.parsing.schemes import scheme_parser
 
 
 TYPE_MAPPING = {
@@ -11,6 +12,7 @@
     'volumes': volume_parser,
     'states': volume_parser,
     'networks': network_parser,
+    'moveschemes': scheme_parser,
 }
 
 def parse(dct):

diff --git a/paths_cli/parsing/schemes.py b/paths_cli/parsing/schemes.py
@@ -0,0 +1,76 @@
+from paths_cli.parsing.core import InstanceBuilder, Parser
+from paths_cli.parsing.tools import custom_eval
+from paths_cli.parsing.shooting import shooting_selector_parser
+from paths_cli.parsing.engines import engine_parser
+from paths_cli.parsing.networks import network_parser
+from paths_cli.parsing.strategies import strategy_parser
+
+build_spring_shooting_scheme = InstanceBuilder(
+    module='openpathsampling',
+    builder='SpringShootingMoveScheme',
+    attribute_table={
+        'network': network_parser,
+        'k_spring': custom_eval,
+        'delta_max': custom_eval,
+        'engine': engine_parser,
+    }
+)
+
+class StrategySchemeInstanceBuilder(InstanceBuilder):
+    """
+    Variant of the InstanceBuilder that appends strategies to a MoveScheme
+    """
+    def __init__(self, builder, attribute_table, defaults=None, module=None,
+                 remapper=None, default_global_strategy=False):
+        from openpathsampling import strategies
+        super().__init__(builder, attribute_table, defaults=defaults,
+                         module=module, remapper=remapper)
+        if default_global_strategy is True:
+            self.default_global = [strategies.OrganizeByMoveGroupStrategy()]
+        elif default_global_strategy is False:
+            self.default_global = []
+        else:
+            self.default_global= [default_global_strategy]
+
+    def __call__(self, dct):
+        new_dct = self._parse_attrs(dct)
+        strategies = new_dct.pop('strategies')
+        scheme = self._build(new_dct)
+        for strat in strategies + self.default_global:
+            scheme.append(strat)
+
+        self.logger.debug(f"strategies: {scheme.strategies}")
+        return scheme
+
+
+build_one_way_shooting_scheme = StrategySchemeInstanceBuilder(
+    module='openpathsampling',
+    builder='OneWayShootingMoveScheme',
+    attribute_table={
+        'network': network_parser,
+        'selector': shooting_selector_parser,
+        'engine': engine_parser,
+        'strategies': strategy_parser,
+    }
+)
+
+build_scheme = StrategySchemeInstanceBuilder(
+    module='openpathsampling',
+    builder='MoveScheme',
+    attribute_table={
+        'network': network_parser,
+        'strategies': strategy_parser,
+    },
+    default_global_strategy=True,
+)
+
+scheme_parser = Parser(
+    type_dispatch={
+        'one-way-shooting': build_one_way_shooting_scheme,
+        'spring-shooting': build_spring_shooting_scheme,
+        'scheme': build_scheme,
+        'default-tis': ...,
+    },
+    label='movescheme'
+)
+
diff --git a/paths_cli/parsing/shooting.py b/paths_cli/parsing/shooting.py
@@ -0,0 +1,31 @@
+from paths_cli.parsing.core import InstanceBuilder, Parser
+from paths_cli.parsing.cvs import cv_parser
+from paths_cli.parsing.tools import custom_eval
+import numpy as np
+
+build_uniform_selector = InstanceBuilder(
+    module='openpathsampling',
+    builder='UniformSelector',
+    attribute_table={}
+)
+
+def remapping_gaussian_stddev(dct):
+    dct['alpha'] = 0.5 / dct.pop('stddev')**2
+    return dct
+
+build_gaussian_selector = InstanceBuilder(
+    module='openpathsampling',
+    builder='GaussianSelector',
+    attribute_table={'cv': cv_parser,
+                     'mean': custom_eval,
+                     'stddev': custom_eval},
+    remapper=remapping_gaussian_stddev
+)
+
+shooting_selector_parser = Parser(
+    type_dispatch={
+        'uniform': build_uniform_selector,
+        'gaussian': build_gaussian_selector,
+    },
+    label='shooting_selector'
+)
diff --git a/paths_cli/parsing/strategies.py b/paths_cli/parsing/strategies.py
@@ -0,0 +1,97 @@
+from paths_cli.parsing.core import InstanceBuilder, Parser
+from paths_cli.parsing.shooting import shooting_selector_parser
+from paths_cli.parsing.engines import engine_parser
+
+build_one_way_shooting_strategy = InstanceBuilder(
+    module='openpathsampling.strategies',
+    builder='OneWayShootingStrategy',
+    attribute_table={
+        'selector': shooting_selector_parser,
+        'engine': engine_parser,
+    },
+    optional_attributes={
+        'group': str,
+        'replace': bool,
+    }
+)
+
+build_two_way_shooting_strategy = InstanceBuilder(
+    module='openpathsampling.strategies',
+    builder='TwoWayShootingStrategy',
+    attribute_table={
+        'modifier': ...,
+        'selector': shooting_selector_parser,
+        'engine': engine_parser,
+    },
+    optional_attributes={
+        'group': str,
+        'replace': bool,
+    }
+)
+
+build_nearest_neighbor_repex_strategy = InstanceBuilder(
+    module='openpathsampling.strategies',
+    builder='NearestNeighborRepExStrategy',
+    attribute_table={},
+    optional_attributes={
+        'group': str,
+        'replace': bool,
+    },
+)
+
+build_all_set_repex_strategy = InstanceBuilder(
+    module='openpathsampling.strategies',
+    builder='AllSetRepExStrategy',
+    attribute_table={},
+    optional_attributes={
+        'group': str,
+        'replace': bool,
+    }
+)
+
+build_path_reversal_strategy = InstanceBuilder(
+    module='openpathsampling.strategies',
+    builder='PathReversalStrategy',
+    attribute_table={},
+    optional_attributes={
+        'group': str,
+        'replace': bool,
+    }
+)
+
+build_minus_move_strategy = InstanceBuilder(
+    module='openpathsampling.strategies',
+    builder='MinusMoveStrategy',
+    attribute_table={
+        'engine': engine_parser,
+    },
+    optional_attributes={
+        'group': str,
+        'replace': bool,
+    }
+)
+
+build_single_replica_minus_move_strategy = InstanceBuilder(
+    module='openpathsampling.strategies',
+    builder='SingleReplicaMinusMoveStrategy',
+    attribute_table={
+        'engine': engine_parser,
+    },
+    optional_attributes={
+        'group': str,
+        'replace': bool,
+    }
+)
+
+strategy_parser = Parser(
+    type_dispatch={
+        'one-way-shooting': build_one_way_shooting_strategy,
+        'two-way-shooting': build_two_way_shooting_strategy,
+        'nearest-neighbor-repex': build_nearest_neighbor_repex_strategy,
+        'all-set-repex': build_all_set_repex_strategy,
+        'path-reversal': build_path_reversal_strategy,
+        'minus': build_minus_move_strategy,
+        'single-rep-minux': build_single_replica_minus_move_strategy,
+    },
+    label="strategy"
+)