sierra-research 1.3.11__py3-none-any.whl → 1.5.0__py3-none-any.whl

sierra/core/experiment/spec.py

@@ -1,6 +1,9 @@
 # Copyright 2020 John Harwell, All rights reserved.
 #
 #  SPDX-License-Identifier: MIT
+"""
+Contains experiment specification bits in the interest of DRY.
+"""
 
 # Core packages
 import typing as tp
@@ -13,64 +16,66 @@ import pathlib
 import sierra.core.variables.batch_criteria as bc
 from sierra.core.utils import ArenaExtent
 from sierra.core.vector import Vector3D
-import sierra.core.plugin_manager as pm
+import sierra.core.plugin as pm
 from sierra.core import types, config
-from sierra.core.experiment import xml
+from sierra.core.experiment import definition
 
 
-class SimpleBatchScaffoldSpec():
-    def __init__(self,
-                 criteria: bc.BatchCriteria,
-                 log: bool = False) -> None:
+class SimpleBatchScaffoldSpec:
+    def __init__(self, criteria: bc.XVarBatchCriteria, log: bool = False) -> None:
         self.criteria = criteria
         self.chgs = criteria.gen_attr_changelist()
-        self.adds = criteria.gen_tag_addlist()
+        self.adds = criteria.gen_element_addlist()
         self.rms = criteria.gen_tag_rmlist()
         self.logger = logging.getLogger(__name__)
-
         self.n_exps = 0
 
         self.mods = []
         self.is_compound = False
 
-        assert len(self.rms) == 0,\
-            "Batch criteria cannot remove XML tags"
+        assert len(self.rms) == 0, "Batch criteria cannot remove expdef elements"
 
         if self.chgs:
             self.mods = self.chgs
             self.n_exps = len(self.chgs)
             if log:
-                self.logger.info(("Calculating scaffold: cli='%s': Modify %s "
-                                  "XML tags per experiment"),
-                                 self.criteria.cli_arg,
-                                 len(self.chgs[0]))
+                self.logger.info(
+                    (
+                        "Executing scaffold: cli=%s: modify %s "
+                        "expdef elements per experiment"
+                    ),
+                    self.criteria.name,
+                    len(self.chgs[0]),
+                )
         elif self.adds:
             self.mods = self.adds
             self.n_exps = len(self.adds)
             if log:
-                self.logger.info(("Calculating scaffold: cli='%s': Add %s XML "
-                                  "tags per experiment"),
-                                 self.criteria.cli_arg,
-                                 len(self.adds[0]))
+                self.logger.info(
+                    (
+                        "Executing scaffold: cli=%s: Add %s expdef "
+                        "elements per experiment"
+                    ),
+                    self.criteria.name,
+                    len(self.adds[0]),
+                )
         else:
-            raise RuntimeError(("This spec can't be used with compound "
-                                "scaffolding"))
+            raise RuntimeError(("This spec can't be used with compound scaffolding"))
 
-    def __iter__(self) -> tp.Iterator[tp.Union[xml.AttrChangeSet,
-                                               xml.TagAddList]]:
+    def __iter__(
+        self,
+    ) -> tp.Iterator[tp.Union[definition.AttrChangeSet, definition.ElementAddList]]:
         return iter(self.mods)
 
     def __len__(self) -> int:
         return self.n_exps
 
 
-class CompoundBatchScaffoldSpec():
-    def __init__(self,
-                 criteria: bc.BatchCriteria,
-                 log: bool = False) -> None:
+class CompoundBatchScaffoldSpec:
+    def __init__(self, criteria: bc.XVarBatchCriteria, log: bool = False) -> None:
         self.criteria = criteria
         self.chgs = criteria.gen_attr_changelist()
-        self.adds = criteria.gen_tag_addlist()
+        self.adds = criteria.gen_element_addlist()
         self.rms = criteria.gen_tag_rmlist()
         self.logger = logging.getLogger(__name__)
 
@@ -79,8 +84,7 @@ class CompoundBatchScaffoldSpec():
         self.is_compound = True
         self.mods = []
 
-        assert len(self.rms) == 0,\
-            "Batch criteria cannot remove XML tags"
+        assert len(self.rms) == 0, "Batch criteria cannot remove expdef elements"
 
         if self.chgs and self.adds:
             for addlist in self.adds:
@@ -90,22 +94,25 @@ class CompoundBatchScaffoldSpec():
                     self.n_exps += 1
 
             if log:
-                self.logger.info(("Calculating scaffold: cli='%s': Add  "
-                                  "%s XML tags AND modify %s XML tags per "
-                                  "per experiment"),
-                                 self.criteria.cli_arg,
-                                 len(self.adds[0]),
-                                 len(self.chgs[0]))
+                self.logger.info(
+                    (
+                        "Executing scaffold: cli=%s: Add  "
+                        "%s expdef elements AND modify %s expdef  "
+                        "elements per experiment"
+                    ),
+                    self.criteria.name,
+                    len(self.adds[0]),
+                    len(self.chgs[0]),
+                )
 
         else:
-            raise RuntimeError(("This spec can only be used with compound "
-                                "scaffolding"))
+            raise RuntimeError(("This spec can only be used with compound scaffolding"))
 
     def __len__(self) -> int:
         return self.n_exps
 
 
-class ExperimentSpec():
+class ExperimentSpec:
     """
     The specification for a single experiment with a batch.
 
@@ -123,72 +130,63 @@ class ExperimentSpec():
     - Full scenario name
     """
 
-    def __init__(self,
-                 criteria: bc.IConcreteBatchCriteria,
-                 exp_num: int,
-                 cmdopts: types.Cmdopts) -> None:
+    def __init__(
+        self,
+        criteria: bc.XVarBatchCriteria,
+        batch_input_root: pathlib.Path,
+        exp_num: int,
+        cmdopts: types.Cmdopts,
+    ) -> None:
         self.exp_num = exp_num
-        exp_name = criteria.gen_exp_names(cmdopts)[exp_num]
+        exp_name = criteria.gen_exp_names()[exp_num]
 
-        self.exp_input_root = pathlib.Path(cmdopts['batch_input_root'], exp_name)
+        self.exp_input_root = batch_input_root / exp_name
         self.exp_def_fpath = self.exp_input_root / config.kPickleLeaf
 
         self.logger = logging.getLogger(__name__)
         self.criteria = criteria
 
-        from_bivar_bc1 = False
-        from_bivar_bc2 = False
-        from_univar_bc = False
-
-        if criteria.is_bivar():
-            bivar = tp.cast(bc.BivarBatchCriteria, criteria)
-            from_bivar_bc1 = hasattr(bivar.criteria1,
-                                     'exp_scenario_name')
-            from_bivar_bc2 = hasattr(bivar.criteria2,
-                                     'exp_scenario_name')
-        else:
-            from_univar_bc = hasattr(criteria,
-                                     'exp_scenario_name')
-
         # Need to get per-experiment arena dimensions from batch criteria, as
         # they might be different for each experiment
-        if from_univar_bc:
-            self.arena_dim = criteria.arena_dims(cmdopts)[exp_num]
-            self.scenario_name = criteria.exp_scenario_name(exp_num)
-            self.logger.debug("Read scenario dimensions '%s' from univariate batch criteria",
-                              self.arena_dim)
-        elif from_bivar_bc1 or from_bivar_bc2:
-            self.arena_dim = criteria.arena_dims(cmdopts)[exp_num]
-            self.logger.debug("Read scenario dimensions '%s' bivariate batch criteria",
-                              self.arena_dim)
-            self.scenario_name = criteria.exp_scenario_name(exp_num)
-
+        if self.criteria.computable_exp_scenario_name():
+            self.arena_dim = self.criteria.arena_dims(cmdopts)[exp_num]
+            self.scenario_name = self.criteria.exp_scenario_name(exp_num)
+            self.logger.debug(
+                "Read scenario dimensions '%s' from batch criteria",
+                self.arena_dim,
+            )
         else:  # Default case: scenario dimensions read from cmdline
-            sgp = pm.module_load_tiered(project=cmdopts['project'],
-                                        path='generators.scenario_generator_parser')
-            kw = sgp.ScenarioGeneratorParser().to_dict(cmdopts['scenario'])
+            module = pm.module_load_tiered(
+                project=cmdopts["project"], path="generators.scenario"
+            )
+            kw = module.to_dict(cmdopts["scenario"])
             self.arena_dim = ArenaExtent(
-                Vector3D(kw['arena_x'], kw['arena_y'], kw['arena_z']))
-            self.logger.debug("Read scenario dimensions %s from cmdline spec",
-                              self.arena_dim)
+                Vector3D(kw["arena_x"], kw["arena_y"], kw["arena_z"])
+            )
+            self.logger.debug(
+                "Read scenario dimensions %s from cmdline spec", self.arena_dim
+            )
 
-            self.scenario_name = cmdopts['scenario']
+            self.scenario_name = cmdopts["scenario"]
 
 
-def scaffold_spec_factory(criteria: bc.BatchCriteria,
-                          **kwargs) -> tp.Union[SimpleBatchScaffoldSpec,
-                                                CompoundBatchScaffoldSpec]:
+def scaffold_spec_factory(
+    criteria: bc.XVarBatchCriteria, **kwargs
+) -> tp.Union[SimpleBatchScaffoldSpec, CompoundBatchScaffoldSpec]:
     chgs = criteria.gen_attr_changelist()
-    adds = criteria.gen_tag_addlist()
+    adds = criteria.gen_element_addlist()
 
     if chgs and adds:
-        logging.debug("Create compound batch experiment scaffolding for '%s'",
-                      criteria.cli_arg)
+        logging.debug(
+            "Create compound batch experiment scaffolding spec for '%s'",
+            criteria.name,
+        )
         return CompoundBatchScaffoldSpec(criteria, **kwargs)
     else:
-        logging.debug("Create simple batch experiment scaffolding for '%s'",
-                      criteria.cli_arg)
+        logging.debug(
+            "Create simple batch experiment scaffolding spec for '%s'", criteria.name
+        )
         return SimpleBatchScaffoldSpec(criteria, **kwargs)
 
 
-__api__ = ['ExperimentSpec']
+__all__ = ["ExperimentSpec"]

sierra/core/exproot.py

@@ -0,0 +1,44 @@
+#
+# Copyright 2024 John Harwell, All rights reserved.
+#
+# SPDX-License Identifier: MIT
+#
+"""
+Container module for functionality for managing paths used by SIERRA.
+"""
+
+# Core packages
+import typing as tp
+
+# 3rd party packages
+
+# Project packages
+from sierra.core import batchroot
+
+
+class PathSet():
+    """
+    The set of filesystem paths under the per-experiment root that SIERRA uses.
+
+    Collected here in the interest of DRY.
+    """
+
+    def __init__(self,
+                 batch: batchroot.PathSet,
+                 exp_name: str,
+                 exp0_name: tp.Optional[str] = None) -> None:
+        self.input_root = batch.input_root / exp_name
+        self.output_root = batch.output_root / exp_name
+        self.graph_root = batch.graph_root / exp_name
+        self.model_root = batch.model_root / exp_name
+        self.stat_root = batch.stat_root / exp_name
+        self.parent = batch.root
+
+        if exp0_name:
+            self.exp0_output_root = batch.output_root / exp0_name
+            self.exp0_stat_root = batch.stat_root / exp0_name
+
+
+__all__ = [
+    "PathSet"
+]

sierra/core/generators/__init__.py

@@ -0,0 +1,10 @@
+# Copyright 2021 John Harwell, All rights reserved.
+#
+#  SPDX-License-Identifier: MIT
+"""Container module for things related to generators."""
+
+# Core packages
+
+# 3rd party packages
+
+# Project packages